Wywołanie std :: funkcja w std :: for_each

Question

mam w istocie następujący kod:

typedef std::function<void()> fnGlobalChangeEvent; 
typedef std::vector<fnGlobalChangeEvent> GlobalTriggers; 

inline void ExecuteGlobal(fnGlobalChangeEvent ev) 
{ 
    ev(); 
} 

GlobalTriggers triggers; 
std::for_each(triggers.begin(), triggers.end(), std::bind(&ExecuteGlobal, _1)); 

Zastosowanie ExecuteGlobal czuje się całkowicie zbędny tutaj, ale nie mogę znaleźć właściwą składnię odpaść telefon.

std::for_each(triggers.begin(), triggers.end(), ExecuteGlobal(_1)); 
std::for_each(triggers.begin(), triggers.end(), std::bind(_1)); 

Obie nie kompilują się.

Jest też bardziej złożona sprawa:

typedef std::function<void (Zot&)> fnChangeEvent; 
typedef std::vector<fnChangeEvent> Triggers; 

inline void Execute(fnChangeEvent ev, Zot& zot) 
{ 
    ev(zot); 
} 

Triggers triggers; 
std::for_each(triggers.begin(), triggers.end(), std::bind(&Execute, _1, zot)); 

Czy można zrobić bez funkcji pomocniczych w tych sprawach?

Answer 1

Jasne, lambda:

std::for_each(
    triggers.begin(), triggers.end(), 
    [](fnChangeEvent ev) { ev(); } 
); 
std::for_each(
    triggers.begin(), triggers.end(), 
    [&zot](fnChangeEvent ev) { ev(zot); } 
); 

Albo jeszcze lepiej, zakres:

for (auto ev : triggers) { 
    ev(); 
} 

// well, I think you can figure out the second one 

Answer 2

Dlaczego nie używasz lambda jak:

std::for_each(triggers.begin(), 
       triggers.end(), 
       [&](fnChangeEvent & e) 
       { 
        e(zot); 
       }); 

lub używając pasmo oparty na pętli jako:

for (auto& e : triggers) { e(zot); } 

który wygląda bardziej zwięźle i czysto.

Answer 3

Oto coś po prostu wymyślił, powiedz mi, czy jest to coś, czego szukasz:

template<typename IT, typename ...Args> 
void call_each(IT begin_, IT end_, Args&&... args) 
{ 
    for (auto i = begin_; i!=end_; ++i) 
     (*i)(std::forward<Args>(args)...); 
} 

następnie można go używać tak:

call_each(triggers.begin(), triggers.end()); 

A dla funkcji z argumenty:

call_each(triggers.begin(), triggers.end(), zot); 

Answer 4

tak, więc nie będę zapominać, że opcja:

typedef std::function<void()> fnGlobalChangeEvent; 
typedef std::vector<fnGlobalChangeEvent> GlobalTriggers; 

GlobalTriggers triggers; 
using namespace std::placeholders; 
std::for_each(triggers.begin(), triggers.end(), std::bind(&fnGlobalChangeEvent::operator(), _1));