Estoy intentando recrear elPatrón observador donde puedo enviar parámetros perfectamente a una función miembro dada de los observadores.

Si intento pasar la dirección de unfunción miembro que tienemúltiples anulaciones, no puede deducir la función miembro correcta basada en los argumentos.

#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;
}

Esto no se compila contemplate argument deduction/substitution failed.

Nota que yo teniaArgs... yUArgs... porque necesito poder pasar parámetros que no son necesariamente del mismo tipo que el tipo de la firma de función, pero que son convertibles a dicho tipo.

Estaba pensando que podría usar unstd::enable_if<std::is_convertible<Args, UArgs>> llamar para desambiguar, pero no creo que pueda hacer esto con un paquete de parámetros de plantilla variadic?

¿Cómo puedo hacer que la deducción de argumentos de la plantilla funcione aquí?