如何调用std::function时兼容带默认参数的成员函数？

问题根源在于：成员函数的默认参数是编译期特性，函数指针本身不会携带默认值信息，std::function无法自动识别并填充这些默认参数，导致签名不匹配。以下是几种可行的解决方案：

方案1：使用模板Lambda（C++20及以上） #

借助C++20的模板Lambda特性，让DoStuff接受任意可调用对象，结合std::invoke统一处理成员函数调用，编译器会自动识别并填充默认参数：

#include <functional>
#include <utility> // 用于std::forward

struct Foo {
  int a(int x) { return x; }
  int b(int x, int y=0) { return x + y; }
  int c(int x, int y=0, int z=1) { return x + y + z; }
};

int complexInstantiationLogic() {
  return 0;
}

void f(Foo f) {
  // 模板Lambda接受任意可调用对象
  auto DoStuff = [] <typename F> (Foo& obj, F&& fn) {
     return std::invoke(std::forward<F>(fn), obj, complexInstantiationLogic());
  };

  DoStuff(f, &Foo::a);
  DoStuff(f, &Foo::b); // 自动使用y的默认值0
  DoStuff(f, &Foo::c); // 自动使用y=0、z=1的默认值
}

方案2：手动包装成员函数（兼容C++11及以上） #

如果项目无法升级到C++20，可以用Lambda手动包装成员函数，补全默认参数，适配std::function要求的签名：

#include <functional>

struct Foo {
  int a(int x) { return x; }
  int b(int x, int y=0) { return x + y; }
  int c(int x, int y=0, int z=1) { return x + y + z; }
};

int complexInstantiationLogic() {
  return 0;
}

void f(Foo f) {
  auto DoStuff = [&] (std::function<int(Foo&, int)> Fn) {
     return Fn(f, complexInstantiationLogic());
  };

  DoStuff(&Foo::a);
  // 用Lambda包装Foo::b，补全默认参数y=0
  DoStuff([](Foo& obj, int x) { return obj.b(x); });
  // 用Lambda包装Foo::c，补全默认参数y=0、z=1
  DoStuff([](Foo& obj, int x) { return obj.c(x); });
}

方案3：将DoStuff改为模板函数（兼容C++11及以上） #

把DoStuff从Lambda改为模板函数，让它自动推导成员函数指针的类型，同样借助std::invoke处理调用并填充默认参数：

#include <functional>
#include <utility> // 用于std::forward

struct Foo {
  int a(int x) { return x; }
  int b(int x, int y=0) { return x + y; }
  int c(int x, int y=0, int z=1) { return x + y + z; }
};

int complexInstantiationLogic() {
  return 0;
}

// 模板函数，接受任意成员函数指针
template<typename MemFn>
auto DoStuff(Foo& obj, MemFn&& fn) {
  return std::invoke(std::forward<MemFn>(fn), obj, complexInstantiationLogic());
}

void f(Foo f) {
  DoStuff(f, &Foo::a);
  DoStuff(f, &Foo::b);
  DoStuff(f, &Foo::c);
}

方案选择建议 #

• 若项目支持C++20，优先选方案1，代码最简洁、可读性最高；
• 若需要兼容C11/C17，方案3更通用，避免手动编写大量包装Lambda；
• 若必须保留std::function的类型约束，再考虑方案2。

内容的提问来源于stack exchange，提问作者yasgur99