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.