1

关于这个问题，这可能过于简单化了，我在这里举一个更复杂的例子。我假装的问题用以下代码描述：

// test3.cpp

using namespace std;

template<typename T>
struct exer
{
    template<typename R, typename... rArgs, typename... pArgs>
    R operator()(R(T::*f)(rArgs...), pArgs&&... args)
    {
       return (t.*f)(forward<pArgs>(args)...);
    }

    T t;
};

struct A
{
    int addition() { return 0; }

    template<typename... Args>
    int addition(int a, Args... args) { return a + addition(args...); }
};

struct B
{
public:
    template<typename... Args>
    int addition(Args&&... args)
    {
       return m_e(&A::addition, forward<Args>(args)...);
    }

private:
    exer<A> m_e;
};

int main()
{
    B b;

    cout << b.addition(1, 2, 3, 4) << endl;
}

这里的问题是，在 的实例化中B::addition， 的类型&A::addition是未知的，因为存在不同的重载。此外，B::addition也不知道必须使用哪个重载。在调用函数之前，它不知道编译器。但是，为了正确指定必须使用的重载exer<A>::operator()，我需要进行转换&A::addition以将其转换为正确的重载。

如何提取目标函数正确重载的类型？

4

1 回答 1

3

换个问题。如果您可以exer使用可调用对象而不是指向成员函数的指针，如下所示：

template<typename T>
struct exer
{
    T t;
    template<typename F, typename... pArgs>
    auto operator()(F f, pArgs&&... args)
    -> decltype(f(t, forward<pArgs>(args)...))
    {
       return f(t, forward<pArgs>(args)...);
    }

};

然后你可以这样做：

struct B
{
public:
    template<typename... Args>
    int addition(Args&&... args)
    {
        struct Invoker {
            auto operator()(A& a, Args&&... args) const
                ->decltype(a.addition(std::forward<Args>(args)...))
            { return a.addition(std::forward<Args>(args)...); }
        };
        return m_e(Invoker(), forward<Args>(args)...);
    }

private:
    exer<A> m_e;
};

现在选择正确A::addition是由编译器使用正常的重载解决规则完成的。

代替Invoker你可以使用 lambda 表达式，它减少了一些重复：

        return m_e( [](A& a, Args&&... as) {
                      return a.addition(forward<Args>(as)...);
                    },
                    forward<Args>(args)...);
于 2013-03-19T20:00:19.330 回答