带有lambda函数参数的重载模板函数的语法 我需要帮助以下C++（17）代码的语法： #包括 结构st_a{ int-var； }; 结构st_b{ 双重var； }; 无效职能（无效（cb）（st_a））{ 圣卢阿； a、 var=3； cb（a）； } 无效职能（无效（cb）（st_b））{ 圣卢布； b、 var=4； cb（b）； } 课堂测试{ 公众： 测试（）{ func（[]（st_a arg）{std:：cout

您正在将lambda函数传递给需要函数指针的对象，因此类型不匹配。我建议更改

func

以接受

std:：function

作为回调，以便可以将lambda传递给它

#包括
void func（标准：：函数cb）{
圣卢阿；
a、 var=3；
cb（a）；
}
void func（标准：：函数cb）{
圣卢布；
b、 var=4；
cb（b）；
}

问题在于此处定义了lambda

func（[this]（st_a arg）{my_func_a（arg）；}）；
func（[this]（st_b arg）{my_func_b（arg）；}）；

具有捕获。您可以将lambda视为实现

operator（）

的类。具有捕获的lambda在该类中具有成员

如果lambda没有捕获，编译器将提供对函数指针的隐式转换，因为它本质上就是这样

如果您有一个带有捕获的lambda，编译器将无法提供隐式转换，因为您将无法将所有这些捕获适应到单个指针中

（如果你对C++中的lambda感兴趣，我建议你看杰森Turns'每周C++），其中很多都是关于lambda的。 <> > C++标准库提供<代码> STD:：函数< /C> >，这是一些类型的删除魔术，老实说，我不完全理解。（我记得看了一个关于C++的每周事件，但是我不能正确地回忆它所做的事情）

---

无论如何，通过使用

std:：function

你会得到一点开销，标准库会让一切正常工作。

其他答案解释了捕获lambda的核心问题，但是你可以通过使用一些模板元编程来解决这个问题，而不必使用

std:function

模板
无效函数（F cb）{
圣卢阿；
a、 var=3；
cb（a）；
}
样板
无效函数（F cb）{
圣卢布；
b、 var=4；
cb（b）；
}

根据这样的定义，如果

F

可以用

st_a

类型的参数调用，编译器将只生成第一个

func

，如果

st_b

类型的参数调用，编译器将只生成第二个

func

。如果这两个参数同时为真，编译器可能会中断（例如，如果在

st_a

和

st_b

之间引入继承）

另一种方法（几乎相当于Yksisarvinen的

std:：is\u invocable\u v

答案，但在C++17之前也可以使用）可以是

template <typename F>
auto func (F cb) -> decltype( cb(std::declval<st_a>()), void() )
 {
   st_a a{3};
   cb(a);
 }

template <typename F>
auto func (F cb) -> decltype( cb(std::declval<st_b>()), void() )
 {
   st_b b{4};
   cb(b);
 }

模板
auto func（F cb）->decltype（cb（std:：declval（）），void（））
{
圣卢西亚{3}；
cb（a）；
}
样板
auto func（F cb）->decltype（cb（std:：declval（）），void（））
{
圣卢布{4}；
cb（b）；
}

no capture lambda可以衰减为指针函数。capture lambda不能。

void func（std:：function cb）

？

error: no matching function for call to ‘func(test::test()::<lambda(st_a)>)’

template<typename F>
void func(F cb) {
  st_a a;
  a.var = 3;
  cb(a);
}

template<typename F>
void func(F cb) {
  st_b b;
  b.var = 4;
  cb(b);
}

error: redefinition of ‘template<class F> void func(F)’

template<typename F, std::enable_if_t<std::is_invocable_v<F, st_a>, bool> = true>
void func(F cb) {
  st_a a;
  a.var = 3;
  cb(a);
}

template<typename F, std::enable_if_t<std::is_invocable_v<F, st_b>, bool> = true>
void func(F cb) {
  st_b b;
  b.var = 4;
  cb(b);
}

template <typename F>
auto func (F cb) -> decltype( cb(std::declval<st_a>()), void() )
 {
   st_a a{3};
   cb(a);
 }

template <typename F>
auto func (F cb) -> decltype( cb(std::declval<st_b>()), void() )
 {
   st_b b{4};
   cb(b);
 }