Wozu boost :: mem_fn, wenn wir boost :: bind haben?

Question

Ich schaue mir die Boost-Bibliotheken an, die in C++ 's Technical Report 1 enthalten waren und versuche zu verstehen, was jeder tut.

Ich habe gerade ein Beispiel für boost::mem_fn ausgeführt und jetzt frage ich mich, was ist der Sinn der Verwendung es anstelle der besseren boost::bind. Soweit ich verstehe, geben beide ein Funktionsobjekt zurück, das auf eine Elementfunktion verweist. Ich finde mem_fn so begrenzt, dass ich kein Szenario finden kann, in dem es besser wäre als bind.

Fehle ich etwas? Gibt es Fälle, in denen bind nicht mem_fn ersetzen kann?

Answer 1

mem_fn ist viel kleiner als bind, wenn Sie also nur die Funktionalität von mem_fn benötigen ist es viel weniger Code in ziehen.

Answer 2

Nun, Bindung hängt von mem_fun ab, also los gehts. Wie und warum werde ich für dich aufbrechen, um zu entdecken, da, obwohl interessant, ich habe nicht die Zeit zu untersuchen, sofort (Bind ist kompliziert).

Answer 3

boost::lambda hat eine ähnliche Überschneidung der Funktionalität mit den beiden Sie erwähnt. Ich denke, sie alle entwickelten sich mit ähnlicher Absicht, etwa zur gleichen Zeit, mit unterschiedlichen Ansätzen, was zu Verwirrung und Inkompatibilitätsproblemen führte. Es wäre schön, wenn sie alle unter einem lambda Regenschirm zusammengeführt würden.

Also, nein, es gibt kein übergreifendes Design, das die Koexistenz beider Bibliotheken fordert.

Answer 4

mem_fn ist kleiner und schneller als bind. Versuchen Sie das folgende Programm mit Ihren Lieblings-Compiler und vergleichen:

1. Die Größe der resultierenden ausführbaren und
2. Die Anzahl der Sekunden gemeldet als ausgegeben werden.

Sie können die Leistung von bind gegen mem_fn vergleichen, indem 1 zu einer 0 in der #if Linie zu ändern.

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

Die Ergebnisse sind unterschiedlich, aber auf meinem aktuellen System der mem_fn Version der ausführbaren Datei ist 220 Bytes kleiner und läuft etwa doppelt so schnell wie die bind Version.

Und als Bonus-Feature, mem_fn nicht Sie benötigen zu erinnern std::placeholders::_1 wie bind does hinzufügen (auf Schmerz eines obskuren Fehler Templat-Compiler).

Also, bevorzugen Sie mem_fn, wenn Sie können.