Question

我基本上有以下法典:

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));

在这里,使用赤贫全球感觉是完全多余的,但我找不到正确的辛迪加来放弃这一呼吁。

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

两者都没有汇编。

还有一个更为复杂的案例:

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));

如果没有帮助者在这些情况下发挥职能是可能的?

Answer 1

Sure, a lambda:

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

或者说,范围越好:

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

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

Answer 2

为什么不把lam子用作:

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

a. 或使用范围以下的 lo:

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

更简明扼要。

Answer 3

在这里,我刚才所想的话告诉我,这是否像你所想的:

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)...);
}

然后,你可以这样使用:

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

对于具有论点的职能:

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

Answer 4

同样,我也 forget忘记了这一选择:

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));

友情链接