valor - que es un parametro en c++

C++ ¿pueden los compiladores alinear un puntero de función?

Question

Supongamos que tengo una función functionProxy que toma una function parámetro genérica y llama a su operator() :

template< typename Function > void functionProxy( Function function ) {
function();
}

El objeto que se le pasa puede ser:

• un functor:

  struct Functor {
  void operator()() const {
  std::cout << "functor!" << std::endl;
  }
  };

• Una función:

  void function( ) {
  std::cout << "function!" << std::endl;
  }

• una función lambda (C ++ 0x):

  [](){ std::cout << "lambda!" << std::endl; }

int main( )
{
functionProxy( Functor() );
functionProxy( function );
functionProxy( [](){ std::cout << "lambda!" << std::endl; } );
return 0;
}

¿El compilador podrá realizar una function en línea dentro de functionProxy en todos los casos anteriores?

Answer 1

¿El compilador puede alinear las llamadas? Sí.

¿Lo hará? Tal vez. Verifique después de saber que es importante .

Answer 2

Cosa segura.

Sabe que el valor de la function es el mismo que el valor que le pasa, conoce la definición de la función, por lo que simplemente reemplaza la definición en línea y llama a la función directamente.

No puedo pensar en una condición en la que un compilador no alinee una llamada de función de una línea, simplemente está reemplazando una llamada de función con una llamada de función, no hay pérdida posible.

Dado este código:

#include <iostream>
template <typename Function>
void functionProxy(Function function)
{
function();
}
struct Functor
{
void operator()() const
{
std::cout << "functor!" << std::endl;
}
};
void function()
{
std::cout << "function!" << std::endl;
}
//#define MANUALLY_INLINE
#ifdef MANUALLY_INLINE
void test()
{
Functor()();
function();
[](){ std::cout << "lambda!" << std::endl; }();
}
#else
void test()
{
functionProxy(Functor());
functionProxy(function);
functionProxy([](){ std::cout << "lambda!" << std::endl; });
}
#endif
int main()
{
test();
}

Con MANUALLY_INLINE definido, obtenemos esto:

test:
00401000 mov eax,dword ptr [__imp_std::endl (402044h)]
00401005 mov ecx,dword ptr [__imp_std::cout (402058h)]
0040100B push eax
0040100C push offset string "functor!" (402114h)
00401011 push ecx
00401012 call std::operator<<<std::char_traits<char> > (401110h)
00401017 add esp,8
0040101A mov ecx,eax
0040101C call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401022 mov edx,dword ptr [__imp_std::endl (402044h)]
00401028 mov eax,dword ptr [__imp_std::cout (402058h)]
0040102D push edx
0040102E push offset string "function!" (402120h)
00401033 push eax
00401034 call std::operator<<<std::char_traits<char> > (401110h)
00401039 add esp,8
0040103C mov ecx,eax
0040103E call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401044 mov ecx,dword ptr [__imp_std::endl (402044h)]
0040104A mov edx,dword ptr [__imp_std::cout (402058h)]
00401050 push ecx
00401051 push offset string "lambda!" (40212Ch)
00401056 push edx
00401057 call std::operator<<<std::char_traits<char> > (401110h)
0040105C add esp,8
0040105F mov ecx,eax
00401061 call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401067 ret

Y sin esto:

test:
00401000 mov eax,dword ptr [__imp_std::endl (402044h)]
00401005 mov ecx,dword ptr [__imp_std::cout (402058h)]
0040100B push eax
0040100C push offset string "functor!" (402114h)
00401011 push ecx
00401012 call std::operator<<<std::char_traits<char> > (401110h)
00401017 add esp,8
0040101A mov ecx,eax
0040101C call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401022 mov edx,dword ptr [__imp_std::endl (402044h)]
00401028 mov eax,dword ptr [__imp_std::cout (402058h)]
0040102D push edx
0040102E push offset string "function!" (402120h)
00401033 push eax
00401034 call std::operator<<<std::char_traits<char> > (401110h)
00401039 add esp,8
0040103C mov ecx,eax
0040103E call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401044 mov ecx,dword ptr [__imp_std::endl (402044h)]
0040104A mov edx,dword ptr [__imp_std::cout (402058h)]
00401050 push ecx
00401051 push offset string "lambda!" (40212Ch)
00401056 push edx
00401057 call std::operator<<<std::char_traits<char> > (401110h)
0040105C add esp,8
0040105F mov ecx,eax
00401061 call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (40204Ch)]
00401067 ret

Lo mismo. (Compilado con MSVC 2010, versión vainilla).

Answer 3

El Functor y el lambda estarán en línea porque son objetos no estáticos (toda la información está disponible en tiempo de compilación).

Los punteros de función y boost :: Function objects (ahora en std: :) no se pueden insertar porque no está claro en el momento de la compilación a qué función apuntan. Si son const, las cosas pueden variar.

Answer 4

He intentado el siguiente código de puntero a lambda con plantillas :

volatile static int a = 0;
template <typename Lambda> class Widget {
public:
Widget(const Lambda* const lambda) : lambda_(lambda) { }
void f() { (*lambda_)(); }
private:
const Lambda* const lambda_;
};
int main() {
auto lambda = [](){ a++; };
Widget<decltype(lambda)> widget(&lambda);
widget.f();
}

GNU g ++ 4.9.2, Intel icpc 16.0.1 y clang ++ 3.5.0 widget.f() ambas widget.f() y (*lambda_)() utilizando -O2 . Es decir, a se incrementó directamente dentro de main() acuerdo con los binarios desensamblados.

La alineación se aplicó incluso con punteros lambda y lambda_ no const (eliminando ambos const ).

Ídem con una variable local y captura lambda:

int main() {
volatile int a = 0;
auto lambda = [&a](){ a++; };
...

Answer 5

Posiblemente. No hay una razón fuerte a favor o en contra, solo depende de lo que hayan implementado los escritores del compilador.