erfinde ich das Rad mit dieser trivialen Methode Call Forwarding Klasse neu?

Question

Ich habe gerade selbst eine Klasse erstellen

template <typename T> struct invoker { 
    void operator()(T& it) const {it();} 
}; 

so konnte ich ein invoker<foo> etwas passieren (was nicht unter meiner Kontrolle ist), die invoker<foo>::operator()(foo&) darauf mit verschiedenen foo Instanzen immer wieder anrufen will, es zu erhalten, Weiterleiten Sie diese Anrufe an die foo::operator()() Methode.

Ich weiß, es sind nur ein paar Zeilen, aber das scheint so etwas zu sein, was wahrscheinlich schon von STLs funktionalem oder boost::bind irgendwie vorgesehen ist. Außer ich kann den Trick nicht sehen, wenn es einen gibt. (Ich bin sicher, ich bin nicht die erste Person, etwas zu verwenden, sehr wie diese, es einen Namen hat?)

Answer 1

Ja, Sie erfinden das Rad neu. std :: mem_fun_ref macht was Sie wollen.

std::vector<foo> foos; 

... 

std::for_each(foos.begin(), foos.end(), std::mem_fun_ref(&foo::operator())); 

Alternativ:

std::vector<foo*> foos; 

... 

std::for_each(foos.begin(), foos.end(), std::mem_fun(&foo::operator())); 

nicht mit zu verwirren zu müssen, ob Ihre param ist ptr oder nicht, ist ein großer Vorteil von boost :: mem_fn.

Alles viel komplexer als das und Sie beginnen in Schwierigkeiten mit den C++ 03 Bindemitteln zu laufen und brauchen etwas ausdrucksvolleres wie boost.bind.

Answer 2

Nun können Sie std::bind verwenden, wahrscheinlich boost::bind auch das gleiche Verhalten zu erreichen:

#include <string> 
#include <iostream> 
#include <functional> 

struct foo { 
    void operator()() { 
     std::cout << "Hallo, im at addr: " << std::hex << this << std::endl; 
    } 
}; 

int main() { 
    std::function<void(foo*)> fun = std::bind(&foo::operator(), std::placeholders::_1); 
    foo f1, f2; 
    fun(&f1); 
    fun(&f2); 
} 

Ausgänge:

Hallo, im at addr: 0xbffc396a 
Hallo, im at addr: 0xbffc3969 

Wenn Sie eine Template-Klasse für das Argument Typ verwenden, können Sie die gleiche behvaiour haben, ohne das Rad neu zu erfinden.

bearbeiten: wie verrückt Eddie darauf hingewiesen, können Sie einfach boost::mem_fn oder std::mem_fn verwenden:

std::function<void(foo*)> fun = std::mem_fn(&foo::operator()); 

Statt bind.