将具有任意参数和占位符的函数存储在类中，然后再调用它

不太清楚DelayedCaller在做什么。如果你重构代码并去掉它，你会得到这样的：

auto c1 = []() {myFunc1(123, 45.6);}; // or use bind, the result is exactly the same
auto c2 = []() {myFunc2("A string");};
vector<function<void()>> v {c1, c2};
v[0]();
v[1](); // ok

现在，如果你试图在这个版本中引入占位符修改，那么它一开始就不起作用的原因就很清楚了：

auto cSome = [](???) {getValueBasic(???)};

你用什么替换???？

getValueBasic接受某些特定类型的参数，它将泄漏到cSome签名中。无论你用多少个模板包装器包装它，它都会泄漏到每个包装器的签名中，直到最外面的一个。CCD_ 10和CCD_。

换句话说，如果你不知道函数的类型，你就不能调用它(有点明显，不是吗？)

键入擦除签名并使所有可调用程序符合同一类型的一种方法是在运行时进行类型检查并对其进行类型转换(也称为dynamic_cast)。另一种是双重派遣。这两种方法都是访问者相同总体思想的不同体现。谷歌"访客模式"获取更多信息。

也许这很适合你。使用c++11

#include <iostream>                                                                                                                                                                                                 
#include <functional>
#include <vector>
namespace test
{

std::vector<std::function<void()>> listeners;
template<typename F, typename... Args>
void add_listener(F call, Args&& ...args )
{   
std::cout << "callback_dispatcher>" << __PRETTY_FUNCTION__ << "enter <<< " << std::endl;                                                 
auto invoke_me = [=]()mutable{
call(std::move(args)...);
};  
listeners.push_back(invoke_me);
}   
void dispatch_all()
{
for(auto func: listeners)
{   
func();
}   
}   
}
int main()
{
std::cout << "Main entered..." << std::endl;

test::add_listener(
[](int a)
{   
std::cout << "void(int) lambda dispatched with a = " << a << std::endl;
},  
5   
);  
test::add_listener(
[](int a, std::string str)
{   
std::cout << "void(int, string) lambda dispatched with a = " << a << ", str = " << str << std::endl;
},  
10, "Hello World!"
);  
test::dispatch_all();
std::cout << "Main exited..." << std::endl;
}

输出：

Main entered...
callback_dispatcher>void test::add_listener(F, Args&& ...) [with F = main()::<lambda(int)>; Args = {int}]enter <<< 
callback_dispatcher>void test::add_listener(F, Args&& ...) [with F = main()::<lambda(int, std::__cxx11::string)>; Args = {int, const char (&)[13]}]enter <<< 
void(int) lambda dispatched with a = 5
void(int, string) lambda dispatched with a = 10, str = Hello World!
Main exited...

请参阅SO_QUESTION，了解在lambda中展开args时使用可变和std:：move的原因。

看看std:：bind，也许还有std:：mem_fn

c+=11版本能够对参数列表进行各种巧妙的转换，以生成类似函数的对象。

当然，Lambdas提供了更大的灵活性，你可以将它们混合在一起。

我在DelayedCaller的修改版本(方法和占位符)中看到了两个主要问题

(1) 现在call()接收到一个参数(类型为T)，因此用一个参数调用func_()；但是func_()仍然定义为std::function<void()>类型，因此无法接收参数[这一点是您的"无匹配功能"错误的原因]

(2) 如果模板化call()，接收类型为T的参数，则还需要模板化成为std::function<void(T)>的func_的类型；所以您必须将整个类模板化。

考虑到计数(1)和(2)，并保持std::unique_ptr，我将您的DelayedCaller重写为dcM1(M表示"方法"，1表示"1个参数")

template <typename T>
class dcM1
{
public:
template <typename TFunction, typename TClass>
static std::unique_ptr<dcM1> setup (TFunction && a_func,
TClass && a_class)
{
auto func = std::bind(std::forward<TFunction>(a_func),
std::forward<TClass>(a_class),
std::placeholders::_1);
return std::unique_ptr<dcM1>(new dcM1(func));
}
void call( T v ) const
{ func_(v); }
private:
using func_type = std::function<void(T)>;
dcM1(func_type && a_ft) : func_(std::forward<func_type>(a_ft))
{ }
func_type func_;
};

并且可以按如下使用

auto cm1f = dcM1<int>::setup(&foo::func, &f);
auto cm1b = dcM1<long>::setup(&bar::func, &b);
cm1f->call(0);
cm1b->call(1L);

以下是的完整工作示例

#include <iostream>
#include <string>
#include <functional>
#include <memory>
void myFunc1 (int arg1, float arg2)
{ std::cout << arg1 << ", " << arg2 << 'n'; }
void myFunc2 (char const * arg1)
{ std::cout << arg1 << 'n'; }
class dcVoid
{
public:
template <typename TFunction, typename... TArgs>
static std::unique_ptr<dcVoid> setup (TFunction && a_func,
TArgs && ... a_args)
{
return std::unique_ptr<dcVoid>(new dcVoid(
std::bind(std::forward<TFunction>(a_func),
std::forward<TArgs>(a_args)...)));
}
void call() const
{ func_(); }
private:
using func_type = std::function<void()>;
dcVoid(func_type && a_ft) : func_(std::forward<func_type>(a_ft))
{ }
func_type func_;
};
template <typename T>
class dcM1
{
public:
template <typename TFunction, typename TClass>
static std::unique_ptr<dcM1> setup (TFunction && a_func,
TClass && a_class)
{
auto func = std::bind(std::forward<TFunction>(a_func),
std::forward<TClass>(a_class),
std::placeholders::_1);
return std::unique_ptr<dcM1>(new dcM1(func));
}
void call( T v ) const
{ func_(v); }
private:
using func_type = std::function<void(T)>;
dcM1(func_type && a_ft) : func_(std::forward<func_type>(a_ft))
{ }
func_type func_;
};
struct foo
{ void func (int i) { std::cout << "foo func: " << i << std::endl; } };
struct bar
{ void func (long l) { std::cout << "bar func: " << l << std::endl; } };
int main ()
{
auto cv1 = dcVoid::setup(&myFunc1, 123, 45.6);
auto cv2 = dcVoid::setup(&myFunc2, "A string");
foo f;
bar b;
auto cm1f = dcM1<int>::setup(&foo::func, &f);
auto cm1b = dcM1<long>::setup(&bar::func, &b);
cv1->call();
cv2->call();
cm1f->call(0);
cm1b->call(1L);
}

好的，所以我知道这已经持续了一段时间。我一直在对不同的事件模式进行大量研究，试图找到更接近我所追求的东西。在详细介绍了所有内容之后，并根据那些在这里留下评论的人的建议，我决定使用Signal/Slot模式，这可能是C++中使用最广泛的事件模式。处理它的方法是让我的所有"逻辑类"(无论是用于gui还是用于计算)都引用第三个"信号事件持有者类"，为了简单起见，我将其称为事件代理。这几乎是我所能得到的。你可能想要的任何事件都可以添加到这个类中，并且可以通过引用事件代理从任何类访问和调用它。我发现了Simon Schneegans制作的一个非常好的信号类，但我正在积极尝试寻找/学习如何让它变得更好(线程安全，也许更快？)。如果有人像我一样感兴趣/寻求帮助，你可以在这里找到我的超级基础测试用例：https://github.com/Moonlight63/QtTestProject

谢谢！