消除作为模板参数传递的重载成员函数指针的歧义

Question

我正在尝试重新创建 观察者模式，我可以在其中完美地将参数转发给观察者的给定成员函数。

如果我尝试传递具有多个覆盖的成员函数的地址，它无法根据参数推断出正确的成员函数。

#include <iostream>
#include <vector>
#include <algorithm>

template<typename Class>
struct observer_list
{
    template<typename Ret, typename... Args, typename... UArgs>
    void call(Ret (Class::*func)(Args...), UArgs&&... args)
    {
        for (auto obj : _observers)
        {
            (obj->*func)(std::forward<UArgs>(args)...);
        }
    }
    std::vector<Class*> _observers;
};

struct foo
{
    void func(const std::string& s)
    {
        std::cout << this << ": " << s << std::endl;
    }
    void func(const double d)
    {
        std::cout << this << ": " << d << std::endl;
    }
};

int main()
{
    observer_list<foo> l;
    foo f1, f2;
    l._observers = { &f1, &f2 };

    l.call(&foo::func, "hello");
    l.call(&foo::func, 0.5);

    return 0;
}

使用template argument deduction/substitution failed 编译失败。

请注意，我有 Args... 和 UArgs...，因为我需要能够传递的参数不一定与函数签名的类型相同，但可以转换为所述类型。

我在想我可以使用 std::enable_if<std::is_convertible<Args, UArgs>> 调用来消除歧义，但我不相信我可以使用可变参数模板参数包来做到这一点？

如何让模板参数推导在这里起作用？

Answer 1

问题就在这里：

l.call(&foo::func, "hello");
l.call(&foo::func, 0.5);

对于这两行，编译器不知道您指的是哪个foo::func。因此，您必须通过强制转换提供缺失的类型信息（即foo:func 的类型）来消除歧义：

l.call(static_cast<void (foo::*)(const std::string&)>(&foo::func), "hello");
l.call(static_cast<void (foo::*)(const double      )>(&foo::func), 0.5);

或者，您可以提供编译器无法推断的模板参数并定义func 的类型：

l.call<void, const std::string&>(&foo::func, "hello");
l.call<void, double            >(&foo::func, 0.5);

请注意，您必须在上面使用double 而不是const double。原因是一般double和const double是两种不同的类型。但是，在一种情况下，double 和 const double 被认为是同一类型：作为函数参数。例如，

void bar(const double);
void bar(double);

不是两个不同的重载，而是实际上是同一个函数。