Warum std::bind über Lambdas in C++14 verwenden?

Vor C++11 habe ich verwendet boost::bind oder boost::lambda viel. Die bind Teil hat es in die Standardbibliothek geschafft (std::bind) wurde der andere Teil Teil der Kernsprache (C++ Lambdas) und machte die Verwendung von Lambdas viel einfacher. Heutzutage benutze ich kaum noch std::bind, da ich mit C++-Lambdas fast alles machen kann. Es gibt einen gültigen Anwendungsfall für std::bind das fällt mir ein:

struct foo
{
  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"

Das C++14-Äquivalent dafür wäre

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

Viel kürzer und prägnanter. (In C ++ 11 funktioniert dies aufgrund der Auto-Parameter noch nicht.) Gibt es einen anderen gültigen Anwendungsfall für std::bind die C++-Lambdas-Alternative schlagen oder ist std::bind überflüssig bei C++14?

Scott Meyers gab a sprechen darüber. Das ist, woran ich mich erinnere:

In C++14 gibt es nichts nützliches bind, was nicht auch mit Lambdas möglich wäre.

In C++11 Es gibt jedoch einige Dinge, die mit Lambdas nicht ausgeführt werden können:

1. Sie können die Variablen während der Erfassung beim Erstellen der Lambdas nicht verschieben. Variablen werden immer als Lvalues ​​erfasst. Für bind kannst du schreiben:

   auto f1 = std::bind(f, 42, _1, std::move(v));
   

2. Ausdrücke können nicht erfasst werden, nur Bezeichner. Für bind kannst du schreiben:

   auto f1 = std::bind(f, 42, _1, a + b);
   

3. Überladen von Argumenten für Funktionsobjekte. Dies wurde bereits in der Frage erwähnt.

4. Perfekt-Forward-Argumente sind nicht möglich

In C++14 all dies möglich.

1. Bewegungsbeispiel:

   auto f1 = [v = std::move(v)](auto arg) { f(42, arg, std::move(v)); };
   

2. Ausdrucksbeispiel:

   auto f1 = [sum = a + b](auto arg) { f(42, arg, sum); };
   

3. Siehe Frage

4. Perfekte Weiterleitung: Sie können schreiben

   auto f1 = [=](auto&& arg) { f(42, std::forward<decltype(arg)>(arg)); };
   

Einige Nachteile der Bindung:

• Bind bindet nach Namen und wenn Sie mehrere Funktionen mit demselben Namen haben (überladene Funktionen), weiß bind nicht, welche zu verwenden ist. Das folgende Beispiel wird nicht kompiliert, während Lambdas damit kein Problem hätten:

  void f(int); void f(char); auto f1 = std::bind(f, _1, 42);
  

• Bei der Verwendung von bind-Funktionen ist es weniger wahrscheinlich, dass sie inline sind

Andererseits könnten Lambdas theoretisch mehr Template-Code generieren als bind. Da Sie für jedes Lambda einen einzigartigen Typ erhalten. Für bind nur, wenn Sie unterschiedliche Argumenttypen und eine andere Funktion haben (ich denke, dass es in der Praxis jedoch nicht sehr oft vorkommt, dass Sie mehrmals mit denselben Argumenten und Funktionen binden).

Was Jonathan Wakely in seiner Antwort erwähnte, ist eigentlich ein weiterer Grund, bind nicht zu verwenden. Ich verstehe nicht, warum Sie Argumente stillschweigend ignorieren wollen.

Manchmal ist es einfach weniger Code. Bedenken Sie:

bool check(int arg1, int arg2, int arg3)
{
  return ....;
}

Dann

wait(std::bind(check,a,b,c));

gegen Lambda

wait([&](){return check(a,b,c);});

Ich denke, dass die Bindung hier einfacher zu lesen ist als das Lambda, das wie a aussieht https://en.wikipedia.org/wiki/Brainfuck

Für mich eine gültige Verwendung für std::bind soll klarstellen, dass ich eine Mitgliedsfunktion als Prädikat verwende. Das heißt, wenn ich nur eine Member-Funktion aufrufe, ist es bind. Wenn ich mit dem Argument zusätzliche Dinge mache (neben dem Aufruf einer Member-Funktion), ist es ein Lambda:

using namespace std;
auto is_empty = bind(&string::empty, placeholders::_1); // bind = just map member
vector<string> strings;
auto first_empty = any_of(strings.begin(), strings.end(), is_empty);

auto print_non_empty = [](const string& s) {            // lambda = more than member
    if(s.empty())                // more than calling empty
        std::cout << "[EMPTY]";  // more than calling empty
    else                         // more than calling empty
        std::cout << s;          // more than calling empty
};
vector<string> strings;
for_each(strings.begin(), strings.end(), print_non_empty);

Ein weiterer Unterschied besteht darin, dass zu bindende Argumente kopiert oder verschoben werden müssen, während ein Lambda Variablen verwenden kann, die als Referenz erfasst wurden. Siehe Beispiel unten:

#include <iostream>
#include <memory>

void p(const int& i) {
    std::cout << i << '\n';
}

int main()
{
    std::unique_ptr<int> f = std::make_unique<int>(3);

    // Direct
    p(*f);

    // Lambda ( ownership of f can stay in main )
    auto lp = [&f](){p(*f);};
    lp();

    // Bind ( does not compile - the arguments to bind are copied or moved)
    auto bp = std::bind(p, *f, std::placeholders::_1);
    bp();
}

Ich bin mir nicht sicher, ob es möglich ist, das Problem zu umgehen, indem Sie die obige Bindung verwenden, ohne die Signatur von zu ändern void p(const int&).

Ich erweitere nur den Kommentar von @BertR zu dieser Antwort auf etwas Testbares, obwohl ich gestehe, dass ich mit std::forward<> keine Lösung zum Laufen bringen konnte.

#include <string>
#include <functional>
using namespace std::string_literals;

struct F {
    bool        operator()(char c, int  i) { return c == i;  };
    std::string operator()(char c, char d) { return ""s + d; };
};

void test() {
    { // using std::bind
        auto f = std::bind(F(), 'a', std::placeholders::_1);
        auto b = f(1);
        auto s = f('b');
    }
    { // using lambda with parameter pack
        auto x = [](auto... args) { return F()('a', args...); };
        auto b = x(1);
        auto s = x('b');
    }
}

Testen Sie bei Compiler-Explorer