Bind Vs Lambda?

Question

У меня вопрос о том, какой стиль является предпочтительным: std :: bind Vs lambda в C++ 0x. Я знаю, что они служат - как-то - разные цели, но позволяют взять пример пересекающихся функций.

Использование lambda:

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

Использование bind:

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

Какой мы должны предпочесть? Зачем? предполагая более сложные ситуации по сравнению с указанным примером. Т.е. какие преимущества/недостатки одного над другим?

Answer 1

Как вы сказали, bind и лямбды не совсем точно нацелены на одну и ту же цель.

Например, для использования и составления алгоритмов STL лямбды являются явными победителями, ИМХО.

Чтобы проиллюстрировать, я помню действительно смешной ответ здесь, когда переполнение стека, где кто-то просил идеи шестизначных магических чисел (например, 0xDEADBEEF, 0xCAFEBABE, 0xDEADDEAD и т. Д.), И ему сказали, что если бы он был настоящим программистом на C++ он бы просто загрузить список английских слов и использовать простой однострочник 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 
    ); 
} 

Этого фрагмента кода, в чистом C++ 98, открыть файл английских слов, сканировать каждое слово и печать только те длиной 8 с буквами 'a', 'b', 'c', 'd', 'e' или 'f'.

Теперь включите C++ 0x и лямбда:

#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); 
    } 
); 
} 

Это еще немного тяжело читать (в основном из-за istream_iterator бизнеса), но намного проще, чем версия привязки :)

Answer 2

Синтаксис C++ 0x lamdba более читабельен, чем синтаксис связывания. После того, как вы переходите к связыванию более 2-3 уровней, код становится практически нечитаемым и его трудно поддерживать. Я бы предпочел более интуитивный синтаксис лямбда.

Answer 3

Я думаю, что это скорее вопрос вкуса. Люди, которые быстро овладевают новыми технологиями или знакомы с функциональным программированием, вероятно, предпочтут лямбда-синтаксис, в то время как более консервативные программисты окончательно предпочтут связывание, так как он больше соответствует традиционному синтаксису C++.

Такое решение должно приниматься в координации с людьми, которые будут работать с кодом, возможно, большинством голосов.

Что не меняет факт, однако, что синтаксис лямбда гораздо более мощный и чище.

Answer 4

Одним из преимуществ lambdas является то, что они более полезны, когда вам нужно добавить немного большую логику поверх существующей функции.

С привязкой вы вынуждены создавать новую функцию/метод/функтор, даже если логика нужна только в этом месте. Вам нужно придумать соответствующее имя, и это может сделать код менее понятным, поскольку он потенциально может привести к раздельной логике.

С помощью лямбда вы можете добавить новую логику внутри лямбда (но не вынуждены, если имеет смысл создать новый вызываемый).

Answer 5

C++ 0x lambdas существенно заменить bind. Нет ничего, что вы могли бы связать, чтобы вы не могли воссоздать тривиальный оберточный лямбда для достижения того же. std :: tr1 :: bind будет идти по пути std :: bind1st и т. д., когда поддержка lambda широко распространена. Это хорошо, потому что по какой-то причине большинству программистов приходится сталкиваться с трудностями.

Answer 6

C++ 0x lambdas являются мономорфными, а связывание может быть полиморфным. У вас не может быть чего-то вроде

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

a и b должны иметь известные типы. С другой стороны, TR1/импульс/феникс/лямбда привязки позволяет это сделать:

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" 

Обратите внимание, что типы А и В не фиксирован. Только когда f фактически используется, эти два будут выведены.