Estoy jugando con las características funcionales de c ++ 11. Una cosa que me parece extraña es que el tipo de una función lambda en realidad NO es un tipo de función <>. Es más, los lambda no parecen jugar realmente bien con el mecanismo de inferencia de tipos.

Se adjunta un pequeño ejemplo en el que probé cambiar los dos argumentos de una función para agregar dos enteros. (El compilador que utilicé era gcc 4.6.2 bajo MinGW). En el ejemplo, el tipo paraaddInt_f ha sido explícitamente definido usando la función <> mientrasaddInt_l es una lambda cuyo tipo es de tipo inferido conauto.

Cuando compilé el código, elflip La función puede aceptar la versión explícitamente definida por tipo de addInt pero no la versión lambda, dando un error que dice quetestCppBind.cpp:15:27: error: no matching function for call to 'flip(<lambda(int, int)>&)'

Las siguientes líneas muestran que se puede aceptar la versión lambda (así como una versión 'sin procesar') si se convierte explícitamente al tipo de función apropiado <>.

Así que mis preguntas son:

¿Por qué es que una función lambda no tiene unafunction<> escribe en primer lugar? En el pequeño ejemplo, ¿por qué noaddInt_l tenerfunction<int (int,int)> como el tipo en lugar de tener un diferente,lambda ¿tipo? Desde la perspectiva de la programación funcional, ¿cuál es la diferencia entre una función / objeto funcional y un lambda?

Si hay una razón fundamental por la que estos dos tienen que ser diferentes. He oído que la lambda se puede convertir afunction<> pero son diferentes ¿Es este un problema / defecto de diseño de C ++ 11, un problema de implementación o hay un beneficio en distinguir a los dos como están? Parece que el tipo de firma deaddInt_l Solo ha proporcionado suficiente información sobre los parámetros y tipos de retorno de la función.

¿Hay alguna forma de escribir la lambda para evitar la conversión explícita de tipos mencionada anteriormente?

Gracias por adelantado.

    //-- testCppBind.cpp --
    #include <functional>
    using namespace std;
    using namespace std::placeholders;

    template <typename T1,typename T2, typename T3>
    function<T3 (T2, T1)> flip(function<T3 (T1, T2)> f) { return bind(f,_2,_1);}

    function<int (int,int)> addInt_f = [](int a,int b) -> int { return a + b;};
    auto addInt_l = [](int a,int b) -> int { return a + b;};

    int addInt0(int a, int b) { return a+b;}

    int main() {
      auto ff = flip(addInt_f);   //ok
      auto ff1 = flip(addInt_l);  //not ok
      auto ff2 = flip((function<int (int,int)>)addInt_l); //ok
      auto ff3 = flip((function<int (int,int)>)addInt0);  //ok

      return 0;
    }