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参数（事件*），如果它会破坏ODR。

问题是，选择好的方法替代。看起来SFINAE无法处理多重继承。我该如何运作？

我的猜测：我以为编译器会设置所有可能的方法，然后通过实例化消除错误的候选项，然后如果仅剩下一个方法，则调用它，否则抛出错误。看起来像编译器那样：它提供了一组可能的方法，并且由于候选对象不止一个，因此可以立即推断出该调用是模棱两可的，因为在实例化这些方法之前，作用域是不同的，仅查看函数名而不查看函数名功能签名。

我知道一个方法可以解决一个常见的超类问题，并强制转换（方法2）或为每种类型生成唯一的ID（方法3），但是我想坚持使用C ++，由于语法的原因，它不能编译并崩溃错误。

Answer 1

函数必须在相同的范围内，以便可以进行重载解析，并且可以使用Player声明将其引入using范围：

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

如何使SFINAE工作来选择通过多重继承继承的模板方法

1 个答案: