将重载的成员函数传递给函数模板

Passing an overloaded member function to function template

本文关键字：函数模板 函数 重载 成员      更新时间：2023-10-16

我想要一个函数，它用提供的可变输入参数调用给定的成员函数。我写了这样的东西：

#include <type_traits>
#include <utility>    
struct A {
constexpr int show(int a, int b) const noexcept {return a + b;}
};
template <typename T, typename MemFn, typename ... Args>
int show(T && obj, MemFn Fn, Args&&... args)
{
return (obj.*Fn)(std::forward<Args>(args)...);
}
int main()
{
constexpr A a;
return show(a, &A::show, 1, 2);
}

只要我的结构中只有一个show方法的定义，它就可以正常工作。只要我添加类似的内容

struct A {
constexpr int show(int a, int b) const noexcept {return a + b;}
constexpr int show(int a) const noexcept {return a * 3;}
};

编译器无法推断成员函数的类型，这确实很有意义，但我想知道是否有解决这个问题的方法，比如在成员函数模板中嵌入输入参数类型之类的？

示例代码可以在这里找到。

这是一个令人烦恼的难题，它不断地导致语言建议试图解决它(P0119，P0834，P1170(。

在此之前，如何在类型上包装调用特定成员函数的问题非常困难，因为该成员函数要么重载，要么是模板，要么采用默认参数。

最简单的方法就是编写一个lambda:

[](A& a, auto&&... args) -> decltype(a.show(FWD(args)...)) { return a.show(FWD(args)...); }

但这实际上并不是那么容易，也不是特别方便——而且它实际上只处理show在非constA上可调用的情况。如果我们有const和非const过载怎么办？还是&和&&？

在我看来，实现这一点的最完整方法是将Boost.HOF与以下宏一起使用：

#define CLASS_MEMBER(T, mem) boost::hof::fix(boost::hof::first_of(
boost::hof::match(                                            
[](auto, T& s, auto&&... args)                            
BOOST_HOF_RETURNS(s.mem(FWD(args)...)),               
[](auto, T&& s, auto&&... args)                           
BOOST_HOF_RETURNS(std::move(s).mem(FWD(args)...)),    
[](auto, T const&& s, auto&&... args)                     
BOOST_HOF_RETURNS(std::move(s).mem(FWD(args)...)),    
[](auto, T const& s, auto&&... args)                      
BOOST_HOF_RETURNS(s.mem(FWD(args)...))),              
[](auto self, auto&& this_, auto&&... args)                   
BOOST_HOF_RETURNS(self(*FWD(this_), FWD(args)...))        
))

在您的情况下，您想要：CLASS_MEMBER(A, show)。这将为您提供一个可以正确调用的函数对象：

auto show_fn = CLASS_MEMBER(A, show);
show_fn(a, 1);       // ok, calls a.show(1)
show_fn(a, 1, 2);    // ok, calls a.show(1, 2)
show_fn(a, 1, 2, 3); // error, no matching call - but sfinae friendly

我想知道是否有解决这个问题的方法，比如在成员函数模板中嵌入输入参数类型之类的？

使用lambdas而不是对象和成员函数指针。例如：

struct A {
constexpr int show(int a, int b) const noexcept {return a + b;}
constexpr int show(int a) const noexcept {return a * 3;}
};
template <typename F, typename ... Args>
int show(F&& f, Args&&... args) {
return std::forward<F>(f)(std::forward<Args>(args)...);
}
int main() {
constexpr A a;
auto f = [&a](auto... args) { return a.show(std::forward<decltype(args)>(args)...); };
show(f, 1);
show(f, 1, 2);
}

您可以使用更具体的成员函数类型来约束函数：

template <typename T, typename... Args>
int show(T && obj, int(std::remove_reference_t<T>::*Fn)(int, int) const, Args&&... args)
{
return (obj.*Fn)(std::forward<Args>(args)...);
}

然而，根据您的用例，这个定义可能过于受限，因为现在Fn参数必须与int(int, int) const签名完全匹配，包括可能的cv和ref限定符。

相关文章：