Vincular a Lambda?

Question

Tengo una pregunta sobre qué estilo se prefiere: std :: bind Vs lambda en C++ 0x. Sé que sirven, de alguna manera, diferentes propósitos, pero tomemos un ejemplo de funcionalidad que se cruza.

Usando lambda:

uniform_int<> distribution(1, 6); 
mt19937 engine; 
// lambda style 
auto dice = [&]() { return distribution(engine); }; 

Usando bind:

uniform_int<> distribution(1, 6); 
mt19937 engine; 
// bind style 
auto dice = bind(distribution, engine); 

Cuál debería preferimos? ¿por qué? asumiendo situaciones más complejas en comparación con el ejemplo mencionado. es decir, ¿cuáles son las ventajas/desventajas de una sobre la otra?

Answer 1

Como dijiste, bind y lambdas no apuntan exactamente al mismo objetivo.

Por ejemplo, para usar y componer algoritmos STL, las lambdas son claras ganadoras, en mi humilde opinión.

Para ilustrar, recuerdo una respuesta muy divertida, aquí en desbordamiento de pila, donde alguien pidió ideas de números mágicos hexagonales (como 0xDEADBEEF, 0xCAFEBABE, 0xDEADDEAD etc.) y se le dijo que si fuera un verdadero programador de C++ él simplemente tendría descargar una lista de palabras en inglés y el uso de un sencillo de una sola línea de C++ :)

#include <iterator> 
#include <string> 
#include <algorithm> 
#include <iostream> 
#include <fstream> 
#include <boost/lambda/lambda.hpp> 
#include <boost/lambda/bind.hpp> 

int main() 
{ 
    using namespace boost::lambda; 
    std::ifstream ifs("wordsEn.txt"); 
    std::remove_copy_if(
     std::istream_iterator<std::string>(ifs), 
     std::istream_iterator<std::string>(), 
     std::ostream_iterator<std::string>(std::cout, "\n"), 
     bind(&std::string::size, _1) != 8u 
      || 
     bind(
      static_cast<std::string::size_type (std::string::*)(const char*, std::string::size_type) const>(
       &std::string::find_first_not_of 
      ), 
      _1, 
      "abcdef", 
      0u 
     ) != std::string::npos 
    ); 
} 

Este fragmento, en C++ puro 98, abra el archivo de palabras en inglés, escanear cada palabra e imprimir solamente los de longitud 8 con letras 'a', 'b', 'c', 'd', 'e' o 'f'.

Ahora, encienda C++ 0X y lambda:

#include <iterator> 
#include <string> 
#include <algorithm> 
#include <iostream> 
#include <fstream> 

int main() 
{ 
std::ifstream ifs("wordsEn.txt"); 
std::copy_if(
    std::istream_iterator<std::string>(ifs), 
    std::istream_iterator<std::string>(), 
    std::ostream_iterator<std::string>(std::cout, "\n"), 
    [](const std::string& s) 
    { 
     return (s.size() == 8 && 
       s.find_first_not_of("abcdef") == std::string::npos); 
    } 
); 
} 

Esto sigue siendo un poco pesado para leer (sobre todo por el negocio istream_iterator), pero mucho más simple que la versión unen :)

Answer 2

La sintaxis lamdba de C++ 0x es más legible que la sintaxis de enlace. Una vez que ingresas a más de 2 o 3 niveles, tu código se vuelve prácticamente ilegible y difícil de mantener. Preferiría la sintaxis lambda más intuitiva.

Answer 3

Creo que es más una cuestión de gusto. Las personas que comprenden rápidamente nuevas tecnologías o que están familiarizadas con la programación funcional probablemente prefieran la sintaxis lambda, mientras que los programadores más conservadores preferirán definitivamente la vinculación, ya que está más a la par con la sintaxis tradicional de C++.

Dicha decisión debe tomarse en coordinación con las personas que trabajarán con el código, probablemente por mayoría de votos.

Lo que no cambia el hecho sin embargo, esa sintaxis lambda es mucho más poderosa y más limpia.

Answer 4

Uno de los beneficios de las lambdas es que son mucho más útiles cuando se necesita agregar un poco de lógica sobre una función existente.

Con bind, se ve obligado a crear una nueva función/método/functor incluso si la lógica solo se necesita en este lugar. Necesitas encontrar un nombre apropiado y puede hacer que el código sea menos comprensible ya que potencialmente te hace dividir la lógica relacionada.

Con lambda, puede agregar la nueva lógica dentro de la lambda (pero no está obligado a hacerlo si tiene sentido crear una nueva llamada).

Answer 5

C++ 0x lambdas esencialmente reemplazar bind. No hay nada que puedas vincular que no puedas recrear un envoltorio trivial lambda para lograr lo mismo. std :: tr1 :: bind irá por el camino de std :: bind1st, etc una vez que el soporte de lambda esté muy extendido. Lo cual es bueno, porque por alguna razón la mayoría de los programadores tienen dificultades para resolver su problema.

Answer 6

C++ 0x Las lambdas son monomórficas, mientras que las vinculadas pueden ser polimórficas. No puede tener algo como

auto f = [](auto a, auto b) { cout << a << ' ' << b; } 
f("test", 1.2f); 

ayb deben tener tipos conocidos. Por otro lado, se unen TR1/refuerzo/Phoenix/lambda le permite hacer esto:

struct foo 
{ 
    typedef void result_type; 

    template < typename A, typename B > 
    void operator()(A a, B b) 
    { 
    cout << a << ' ' << b; 
    } 
}; 

auto f = bind(foo(), _1, _2); 
f("test", 1.2f); // will print "test 1.2" 

Tenga en cuenta que los tipos A y B son no fijado aquí. Solo cuando se usa f, estos dos se deducirán.