C++ Función enlazar argumentos de repetición para curried function

Question

Estoy tratando de entender el concepto de currying y llamar a una función que concatena tres cadenas pero pasando solo dos cadenas y usando el segundo argumento dos veces.

Sin embargo, cuando hago esto, el segundo argumento no se envía a la función e imprime una cadena vacía. ¿Es un error realmente obvio?

string concatthreestrings(string a,string b,string c){ 
    cout<<"Value of A: "<<a<<endl; 
    cout<<"Value of B: "<<b<<endl; 
    cout<<"Value of C: "<<c<<endl; 
    return a+b+c; 
} 


int main() 
{ 
    typedef std::function< string(string,string) > fun_t ; 
    using namespace std::placeholders; 
    fun_t fn = std::bind(concatthreestrings, _1, _2, _2); 
    cout<<endl<<fn("First","Second")<<endl; 

} 

Esto está dando la salida siguiente. No usar el _2 dos veces significa que el segundo argumento se pasa tanto para el segundo como para el tercero. Si utiliza una cadena en su lugar, funciona bien.

Answer 1

cadenas de copia es caro. Como std::bind cree que los valores de los marcadores de posición solo se usan una vez, realiza un std::move en las cadenas. Esto se hace para cada parámetro y, como consecuencia, ya sea b o c se mueve, es decir, cadena vacía.

Usted puede cambiar ese comportamiento diciendo explícitamente lo que quiere decir, haciendo pasar los argumentos por referencia const-:

string concatthreestrings(string const& a,string const& b,string const& c) 

Ahora, que debería funcionar.

Answer 2

me hicieron unas pruebas utilizando este ejemplo más pequeño que presenta el mismo comportamiento que tenga:

#include <functional> 
#include <iostream> 
#include <string> 

using std::string; 

void print(string s1, string s2) 
{ 
    std::cout << s1 << s2 << '\n'; 
} 

int main() 
{ 
    using namespace std::placeholders; 

    typedef std::function< void(string) > fn_t; 

    fn_t func = std::bind(print, _1, _1); 

    std::string foo("foo"); 
    func(foo); 
} 

// outputs: foo 

Tenga en cuenta que he definido un objeto de cadena llamado "foo" en lugar de utilizar literales de cadena. El comportamiento es el mismo, por lo que el problema no está relacionado con esto.

Creo que el problema viene de su typedef. El retorno de bind (que no se especifica) se convierte en una función tomando stringpor valor, mientras que el envoltorio devuelto por bind probablemente toma sus argumentos por rvalue-reference y los reenvía perfectamente. En lugar de usar su propio typedef, debe usar la palabra clave auto, de modo que el compilador deduzca automáticamente el tipo de func. Si modificamos el principal de la siguiente manera, obtenemos el comportamiento esperado:

int main() 
{ 
    using namespace std::placeholders; 

    auto func = std::bind(print, _1, _1); 

    std::string foo("foo"); 
    func(foo); 
} 

// outputs: foofoo 

Otra solución es reemplazar el typedef para que func toma su parámetro por referencia a const:

typedef std::function< void(string const &) > fn_t; 

Pongo 'Realmente entiendo por qué el otro typedef no funciona ... Es de suponer que la cadena se mueve, como @ipc notó, pero no sé en qué punto de la ejecución sucede esto. Ni siquiera estoy seguro de que esto sea un comportamiento estándar, ya que tanto function como el contenedor devuelto por bind deben usar el reenvío perfecto. Quizás GCC incluye algunas optimizaciones que mueven los argumentos del contenedor cuando se pasan por valor?

Edición

Hice algunas pruebas, resulta que la aplicación de std::function de GCC realiza un movimiento en sus argumentos, mientras que el retorno envoltorio por std::bind no lo hace. Todavía no sé si esto es estándar, voy a escribir una pregunta sobre eso.