c++ - 如何让SFINAE工作选择通过多重继承继承的模板方法

Question

尝试实现观察者模式，我希望主题和观察者代表所有可能的事件类型(避免重复代码)。我还想允许类通过多重继承从主题继承多次，以便被多个事件观察到。一种解决方案是制作 register/notify/etc... 方法模板，使其“喜欢”不同的名称但具有相同的代码，并消除调用的歧义，而无需制作包装函数。

我想要的东西:

object obj;
obj.registerEvent<Event1>(observer1);
obj.registerEvent<Event2>(observer2);
obj.registerEvent<Event3>(observer3);
...

实际代码:

#include <algorithm>
#include <type_traits>
#include <set>
#include <gtest/gtest.h>

template<typename Event>
class Observer
{
public:

protected:
    Observer() = default;

public:
    virtual void update() = 0;
};

template<typename Event>
class Subject
{
private:
    std::set<Observer<Event>*> m_observers;

protected:
    Subject() = default;

public:

#define same_template \
    template<class T, class = typename std::enable_if<std::is_same<T, Event>::value>::type>

    same_template
    void registerObserver(Observer<Event>* observer, Event* = 0)
    {
        m_observers.insert(observer);
    }

    same_template
    void removeObserver(Observer<Event>* observer, Event* = 0)
    {
        m_observers.erase(observer);
    }

    same_template
    void notifyObservers()
    {
        std::for_each(m_observers.begin(), m_observers.end(), [] (Observer<Event> *observer) {
            observer->update();
        });
    }
};

TEST(PatternObserverTest, CompilationTest)
{

    struct Move {};
    struct Jump {};
    struct Player : Subject<Move>, Subject<Jump> {

        void move()
        {
            notifyObservers<Move>(); // ERROR: member found in multiple bases classes of different types
        }

        void jump()
        {
            notifyObservers<Jump>(); // ERROR: member found in multiple bases classes of different types
        }
    };

    struct Level : Observer<Move>, Observer<Jump> {

        void update()
        {

        }
    };

    Player player;
    Level level;

    player.template registerObserver<Move>(&level); // ERROR: member found in multiple bases classes of different types
}

我什至尝试添加一个 foo 参数 (Event*)，如果它会破坏 ODR。

问题是，要选择好的方法覆盖。看起来 SFINAE 不适用于多重继承。我怎样才能让它发挥作用？

我的猜测:我认为编译器会生成一组所有可能的方法，然后通过实例化消除错误的候选者，然后如果正好有 1 个剩余方法，则调用它，否则会抛出错误。看起来编译器是这样做的:它创建了一组可能的方法，并且因为有不止一个候选者，所以可以立即推断出调用是不明确的，因为在实例化方法之前作用域是不同的，只看函数名而不看函数名函数签名。

我知道可以使用通用父类(super class)和强制转换(方法 2)或为每个类型生成唯一 ID(方法 3)来解决问题，但我想坚持使用 C++，因为语法原因无法编译和崩溃错误。

Answer 1

函数必须在相同的范围内才能进行重载解析，并且可以通过 using 声明将其引入 Player 范围:

struct Player : Subject<Move>, Subject<Jump>
{
    using Subject<Move>::notifyObservers;
    using Subject<Jump>::notifyObservers;
    using Subject<Move>::registerObserver;
    using Subject<Jump>::registerObserver;

    void move()
    {
        notifyObservers<Move>();
    }

    void jump()
    {
        notifyObservers<Jump>();
    }
};

DEMO