¿De qué sirve usar boost :: mem_fn si tenemos boost :: bind?

Question

Echo un vistazo a las bibliotecas de Boost que se incluyeron en el Informe técnico 1 de C++ e intento entender qué hace cada una.

Acabo de ejecutar un ejemplo para boost::mem_fn y ahora me pregunto cuál es el punto de usarlo en lugar del mejor boost::bind. Por lo que yo entiendo, ambos devuelven un objeto de función que apunta a una función miembro. Encuentro mem_fn tan limitado que no puedo encontrar un escenario donde usarlo sería mejor que bind.

¿Echo de menos algo? ¿Hay algún caso en el que bind no pueda reemplazar mem_fn?

Answer 1

mem_fn es mucho más pequeño que bind, por lo que si sólo se necesita la funcionalidad de mem_fn Es mucho menos código para tirar en.

Answer 2

Bueno, vincular depende de mem_fun así que ahí lo tienes. Cómo y por qué lo dejo para que lo descubras, aunque, aunque interesante, no tengo tiempo para investigar en este momento (el enlace es complicado).

Answer 3

boost::lambda tiene una superposición de funcionalidad similar a las dos que mencionaste. Creo que todos evolucionaron con una intención similar, casi al mismo tiempo, con diferentes enfoques, lo que generó confusión y problemas de incompatibilidad. Sería bueno si todos se fusionaran bajo un paraguas lambda.

Por lo tanto, no, no existe un diseño global que requiera la coexistencia de ambas bibliotecas.

Answer 4

mem_fn es más pequeño y más rápido que bind. Pruebe el siguiente programa con su compilador favorito y compare:

1. El tamaño del ejecutable resultante y
2. El número de segundos reportados como se gasta.

Es posible comparar el rendimiento de bind frente mem_fn cambiando el 1 a 0 en la línea #if.

#include <iostream> 
#include <functional> 
#include <chrono> 

struct Foo 
{ 
    void bar() {} 
}; 

int main(int argc, const char * argv[]) 
{ 
#if 1 
    auto bound = std::bind(&Foo::bar, std::placeholders::_1); 
#else 
    auto bound = std::mem_fn(&Foo::bar); 
#endif 
    Foo foo; 
    auto start = std::chrono::high_resolution_clock::now(); 
    for(size_t i = 0; i < 100000000; ++i) 
    { 
     bound(foo); 
    } 
    auto end = std::chrono::high_resolution_clock::now(); 
    auto delta = std::chrono::duration_cast< std::chrono::duration<double>>(end - start); 
    std::cout << "seconds = " << delta.count() << std::endl; 
    return 0; 
} 

Los resultados pueden variar, pero en mi sistema actual de la versión mem_fn del ejecutable es de 220 bytes más pequeña y corre alrededor de dos veces más rápido que la versión bind.

Y como bonus, mem_fn no requiere que recuerde añadir std::placeholders::_1 como bind does (so pena de un error del compilador con plantilla oscura).

Por lo tanto, prefiera mem_fn cuando pueda.