¿Por qué usar std:: bind sobre lambdas en C++14?

std::bind todavía puede hacer una cosa lambdas polimórfica no puede: invocar funciones sobrecargadas

struct F {
  bool operator()(char, int);
  std::string operator()(char, char);
};

auto f = std::bind(F(), 'a', std::placeholders::_1);
bool b = f(1);
std::string s = f('b');

El envoltorio de llamada creado por la expresión bind llama a diferentes funciones dependiendo de los argumentos que le dé, el cierre de un lambda polimórfico de C++14 puede tomar diferentes tipos de argumentos, pero no puede tomar un número diferente de argumentos, y siempre invoca (especializaciones de) la misma función en el cierre. Corrección: ver los comentarios abajo

El wrapper devuelto por std::bind también se puede llamar con demasiados argumentos y los ignorará, mientras que un cierre creado por una lambda diagnosticará los intentos de pasar demasiados argumentos ... pero no lo considero un beneficio de std::bind :)

Para mí, un uso válido para std::bind es dejar claro que estoy usando una función miembro como predicado. Es decir, si todo lo que hago es llamar a una función miembro, es bind. Si hago cosas adicionales con el argumento (además de llamar a una función memeber), es una 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);

A veces es solo menos código. Considere esto:

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

Entonces

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

Vs lambda

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

Creo que bind es más fácil de leer aquí en comparación con la lambda que parece un https://en.wikipedia.org/wiki/Brainfuck

Otra diferencia es que los argumentos para enlazar deben ser copiados o movidos, mientras que una lambda puede usar variables capturadas por referencia. Véase el ejemplo siguiente:

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

No estoy seguro de si es posible solucionar el problema de usar el enlace anterior sin cambiar la firma de void p(const int&).

Simplemente expandiendo el comentario de @BertR a esta respuesta a algo comprobable, aunque confieso que no pude conseguir una solución usando std::forward para trabajar.

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

Prueba en Compiler Explorer