上下文
我想将成员函数和特定对象包装到函数对象中(稍后我将用作回调(。我想为不同的成员函数和对象编写一次这个包装函数，特别是因为我的实际 lambda 在调用包装方法之前做了一些额外的工作。以下是一些可能的实现：
#include <iostream>
#include <string>
#include <utility>
template <class ClassT, class... ArgsT>
auto getCallbackPtr(ClassT* obj, void(ClassT::* memfn)(ArgsT...))
{
return [obj, memfn](ArgsT&&... args) {
(obj->*memfn)(std::forward<ArgsT>(args)...);
};
}
template <auto memFn, class ClassT>
auto getCallbackTemplate(ClassT* obj)
{
return [obj](auto&&... args){
return (obj->*memFn)(std::forward<decltype(args)>(args)...);
};
}
template <auto memFn, class ClassT, class... ArgsT>
auto getCallbackRedundant(ClassT* obj)
{
return [obj](ArgsT&&... args){
return (obj->*memFn)(std::forward<ArgsT&&>(args)...);
};
}
// Example of use
class Foo {
public:
void bar(size_t& x, const std::string& s) { x=s.size(); }
};
int main() {
Foo f;
auto c1 = getCallbackPtr(&f, &Foo::bar);
size_t x1; c1(x1, "123"); std::cout << "c1:" << x1 << "n";
auto c2 = getCallbackTemplate<&Foo::bar>(&f);
size_t x2; c2(x2, "123"); std::cout << "c2:" << x2 << "n";
auto c3 = getCallbackRedundant<&Foo::bar, Foo, size_t&, const std::string&>(&f);
size_t x3; c3(x3, "123"); std::cout << "c3:" << x3 << "n";
}
问题(简而言之(
我想要一个结合了上述三个功能不同方面的函数：
- 它应该将成员函数作为编译时模板参数，这与
getCallbackPtr()不同。 - 它的
operator()不应该是模板化函数，不像getCallbackTemplate(). - 它的模板参数(成员函数指针除外(应该从函数使用中推断出来，不像
getCallbackRedundant()。
一些细节
以下是我希望成员函数成为模板参数的原因，尽管我必须承认这些在实践中可能不会产生显着的影响：
- 优化程序可能会直接调用成员函数，而不是通过函数指针调用。事实上，由于这是调用成员函数的唯一位置，因此编译器甚至可能将其内联到 lambda 中。
- 生成的函数对象较小(一个指针而不是一个指针加一个成员函数指针(，因此更有可能适合
std::function的占用空间(小对象优化(。
以下是具有模板化operator()的getCallbackTemplate()的问题：
- 它不适用于Visual Studio。这对我来说是一个表演障碍。(错误是
error C3533: a parameter cannot have a type that contains 'auto'，参考template <auto memFn, class ClassT>。 - 如果传入错误类型的参数，我怀疑它会比非模板化
operator()具有更复杂和令人困惑的编译器错误(诚然，这只是一种预感(。 - 模板化
operator()无法接受参数的初始值设定项列表。这对我来说根本不是一个问题，但我提到它是为了记录在案。
我认为想要推断模板参数的原因相当清楚：getCallbackRedundant()令人分心的冗长且更难使用。
这能做到吗？如何？
推导参数的一种简单方法是使用部分模板专用化。
在此示例中，我通过将非类型成员函数指针及其类型转发到自定义函子来解决问题，然后返回该函数。
部分专注于该类型，其余的则直截了当。
#include <iostream>
#include <string>
template <auto memFnPtr, class memFn>
struct getCallbackTemplate;
template <auto memFnPtr, class Ret, class ClassT, class... Args>
struct getCallbackTemplate<memFnPtr, Ret(ClassT::*)(Args...)>
{
getCallbackTemplate (ClassT* obj) : m_obj(obj) {}
Ret operator()(Args... args) {
return (m_obj->*memFnPtr)(std::forward<Args>(args)...);
}
ClassT* m_obj;
};
template <auto memFn, class ClassT>
auto getCallback(ClassT* obj) {
return getCallbackTemplate<memFn, decltype(memFn)>(obj);
}
class Foo {
public:
void bar(std::size_t& x, const std::string& s) { x=s.size(); }
};
int main() {
Foo f;
auto c1 = getCallback<&Foo::bar>(&f);
size_t x1; c1(x1, "123"); std::cout << "c1:" << x1 << "n";
}
我想要一个结合上述三个函数不同方面的函数 [...]
如果我理解正确，你想要什么...在我看来，这是可能的，但我只看到一个复杂的解决方案。
希望其他人能提出一种更简单的方法，我使用了几个帮助程序：一个声明的仅模板函数gth1()用于检测方法指针的Args...
template <typename ClassT, typename ... ArgsT>
constexpr auto gth1 (void(ClassT::*)(ArgsT...)) -> std::tuple<ArgsT...>;
以及模板的专用化gth2结构，使用构造和返回 lambda 的静态方法(霍尔特的更正：谢谢！
template <typename, typename, auto>
struct gth2;
template <typename ClassT, typename ... ArgsT, auto memFn>
struct gth2<ClassT, std::tuple<ArgsT...>, memFn>
{
static auto getLambda (ClassT * obj)
{ return [obj](ArgsT ... args)
{ return (obj->*memFn)(std::forward<ArgsT>(args)...); }; }
};
现在你可以编写一个getCallback()函数，如下所示
template <auto memFn, typename ClassT>
auto getCallback (ClassT * obj)
{ return gth2<ClassT, decltype(gth1(memFn)), memFn>::getLambda(obj); }
以下是完整的工作示例
#include <iostream>
template <typename, typename, auto>
struct gth2;
template <typename ClassT, typename ... ArgsT, auto memFn>
struct gth2<ClassT, std::tuple<ArgsT...>, memFn>
{
static auto getLambda (ClassT * obj)
{ return [obj](ArgsT ... args)
{ return (obj->*memFn)(std::forward<ArgsT>(args)...); }; }
};
template <typename ClassT, typename ... ArgsT>
constexpr auto gth1 (void(ClassT::*)(ArgsT...)) -> std::tuple<ArgsT...>;
template <auto memFn, typename ClassT>
auto getCallback (ClassT * obj)
{ return gth2<ClassT, decltype(gth1(memFn)), memFn>::getLambda(obj); }
// Example of use
struct Foo
{ void bar(size_t& x, const std::string& s) { x=s.size(); } };
int main ()
{
Foo f;
auto l { getCallback<&Foo::bar>(&f) };
size_t x;
l(x, "1234567");
std::cout << x << "n";
}
这是另一种可能性。它的灵感来自其他答案，但是虽然这些答案都使用一些部分模板专用化，但这个答案只使用函数模板参数推导。
inner 函数采用第二个参数，其类型用于此推导，其运行时值等于非类型模板参数的编译时值。它在运行时被忽略，特别是它不会被 lambda 捕获。
template <auto memFn, class ClassT, class RetT, class... ArgsT>
inline auto getCallbackInner(ClassT* obj, RetT(ClassT::*)(ArgsT...))
{
return [obj](ArgsT... args)->RetT {
return (obj->*memFn)(std::forward<ArgsT>(args)...);
};
}
template <auto memFn, class ClassT>
auto getCallback(ClassT* obj)
{
return getCallbackInner<memFn, ClassT>(obj, memFn);
}
与其他两个答案一样，这个答案仍然使用 C++17 标准中的自动模板参数，因此它在 Visual Studio 中不起作用。这很遗憾，但似乎只有 C++14 是不可能的。
脚注：
另一个更主观但可能最正确的答案是，我不应该首先尝试将成员函数作为模板参数传递。原始getCallbackPtr()，它只是将成员函数指针绑定到 lambda 中，可能比任何其他可能性被更多的人(以及更多的编译器(理解。通过成员函数指针间接寻址的性能成本可能微不足道，而使用模板技巧的维护成本很高，因此我认为我实际上会在实践中使用该版本，除非有可证明的性能成本。