C++ C+中的回调+；

我正在从事一个项目，我需要回调，因为回调使我们的工作更轻松，并帮助我们编写更清晰的代码。但我找不到

< C++中是否有类似于C中的委托的回调？ 如果是，如何使用？ 如果没有，还有其他选择吗？

我不知道C#也不知道代表。因此，我在此补充我将用作回答您问题的基础的内容（摘自）：

委托是一种类型，它表示对具有 特定参数列表和返回类型。当您实例化 委托时，可以将其实例与具有 兼容的签名和返回类型。您可以调用（或调用） 方法通过委托实例

---

<>我相信C++没有直接取代C代表，但是它有。您可以在

std:：function

中存储几乎所有可调用的函数，以便以后调用。定义可动态调用的最方便的方法是lambda表达式：

#include <iostream>
#include <functional>
#include <vector>

struct foo {
    std::vector< std::function< void()>> callbacks;
    void call_all() {
        for (auto& f : callbacks){
            f();
        }
    }
};

void bar() {
    std::cout << "I am a callback\n";
}

int main() {
    foo f;
    f.callbacks.push_back(bar);
    f.callbacks.push_back( [](){ std::cout << "I am another callback"; });
    f.call_all();
}

#包括
#包括
#包括
结构foo{
std:：vector>回调；
void call_all（）{
用于（自动&f:回调）{
f（）；
}
}
};
空条（）{
std：：cout经过大量的研究和您的帮助，现在我有了一个
委托系统
运行在
C++
中，几乎就像我们在
C#
中看到的那样。下面是完整的代码：-

#include <iostream>
#include <vector>
#include <string>

template <typename T, typename... Args>
class Delegate
{
    private:
        typedef T (*Function) (Args... args);
        std::vector <Function> functions;

    public :
        Delegate ()
        {
            functions = std::vector <Function> ();
        }

        ~Delegate ()
        {
            functions.clear ();
        }

        const void Invoke (const Args&&... args) const
        {
            for (Function func : functions)
            {
                func (args...);
            }
        }

        void Invoke (Args&&... args)
        {
            for (Function func : functions)
            {
                func (args...);
            }
        }

        const void operator () (const Args&&... args) const
        {
            for (Function func : functions)
            {
                func (args...);
            }
        }

        void operator () (Args&&... args)
        {
            for (Function func : functions)
            {
                func (args...);
            }
        }

        const void operator += (const Function func) const
        {
            functions.push_back (func);
        }

        void operator += (Function func)
        {
            functions.push_back (func);
        }

        const void AddListener (const Function func) const
        {
            functions.push_back (func);
        }

        void AddListener (Function func)
        {
            functions.push_back (func);
        }
};

void Log1 (const char* msg)
{
    std :: cout << msg << std :: endl;
    std :: cout << "Called by Log 1" << std :: endl;
}

void Log2 (const char* msg)
{
    std :: cout << msg << std :: endl;
    std :: cout << "Called by Log 2" << std :: endl;
}

int main ()
{
    Delegate <void, const char*> del;
    del += Log1;
    del += Log2;
    del ("Hello World!");
    std :: cin.get ();
}

#包括
#包括
#包括
模板
类委托
{
私人：
类型定义T（*函数）（参数…参数）；
向量函数；
公众：
代表（）
{
functions=std:：vector（）；
}
~Delegate（）
{
functions.clear（）；
}
const void Invoke（const Args&&…Args）const
{
for（函数func:functions）
{
func（args…）；
}
}
无效调用（Args&&…Args）
{
for（函数func:functions）
{
func（args…）；
}
}
const void运算符（）（const Args&&…Args）const
{
for（函数func:functions）
{
func（args…）；
}
}
void运算符（）（Args&&…Args）
{
for（函数func:functions）
{
func（args…）；
}
}
常量void运算符+=（常量函数func）常量
{
functions.push_back（func）；
}
void运算符+=（函数func）
{
functions.push_back（func）；
}
常量void AddListener（常量函数func）常量
{
functions.push_back（func）；
}
void AddListener（函数func）
{
functions.push_back（func）；
}
};
无效日志1（常量字符*msg）
{
std:：cout lambdas和
std:：function
是我在需要存储回调时会使用的。回调是一种范例，一种可以将代码作为函数编写的思想，将该函数传递给程序的其他部分，并期望在某个时间/事件调用它。在C中，有编写委托和VM支持的概念也就是说，在C++中，你可以传递函数的地址（参见函数指针），或者使用包装器，比如STD::For函数或函子对象。performance@Hrisip我可以想象你为什么这么说，但请不要在没有“为什么”的情况下传播这种手工推荐。这只会导致cargo cult。微小的开销是由于类型擦除和某种形式的运行时多态性造成的。因此，避免
std:：function
而使用eg运行时多态性是毫无意义的。如果您的问题已经解决，请将答案标记为已接受。如果这不是解决您问题的答案（应该有；非常详细）请发布问题的答案，解释您是如何解决问题的。将问题标记为“已解决”并编辑问题以包含答案是不可接受的。问题部分应仅包含问题