选择要覆盖哪个基类的方法

Question

鉴于以下情况：

class Observer
{
    public:
        virtual void Observe(Parameter p) = 0;
};

template<size_t Tag>
class TaggedObserver : public Observer { };

class Thing : public TaggedObserver<0>, TaggedObserver<1>
{
    public:
        virtual void Observe(Parameter p) override;
};

Thing::Observe 覆盖 TaggedObserver<0>::Observe 和 TaggedObserver<1>::Observe。
有没有办法为每个基类提供不同的覆盖？
基本原理：我希望该类能够观察两个相同类型的通知源，每个源具有不同的操作，而不必诉诸在参数中传递源然后在if/switch 中检查它。

Answer 1

为了提供不同的覆盖，需要定义不同的派生类，例如：

class Observer
{
public:
    virtual void Observe(Parameter p) = 0;
};

template<size_t Tag>
class TaggedObserver : public Observer
{
};

class TaggedObserverZero : public TaggedObserver<0>
{
public:
    virtual void Observe(Parameter p)
    {
        // do something ...
    }
};

class TaggedObserverOne : public TaggedObserver<1>
{
public:
    virtual void Observe(Parameter p)
    {
        // do something else ...
    }
};

但是，如果您希望 Thing::Observe() 首先接收 Parameter 并将其分派到适当的基类，则无法避免在 Thing 中使用 if 语句（或等效语句），因为它继承TaggedObserver::Observe() 的多个副本，需要决定调用哪一个：

class Thing : public Observer, TaggedObserverZero, TaggedObserverOne
{
public:
    virtual void Observe(Parameter p)
    {
        if (some condition)
            TaggedObserverZero::Observe(p);
        else if (some other condition)
            TaggedObserverOne::Observe(p);
    }
};

或者，你可以无条件地给他们俩打电话，让他​​们自己想办法：

class TaggedObserverZero : public TaggedObserver<0>
{
public:
    virtual void Observe(Parameter p)
    {
        if (some condition)
            // do something ...
    }
};

class TaggedObserverOne : public TaggedObserver<1>
{
public:
    virtual void Observe(Parameter p)
    {
        if (some other condition)
            // do something else ...
    }
};

class Thing : public Observer, TaggedObserverZero, TaggedObserverOne
{
public:
    virtual void Observe(Parameter p)
    {
        TaggedObserverZero::Observe(p);
        TaggedObserverOne::Observe(p);
    }
};

Answer 2

在TaggedObserver 中实现它们（如果需要，提供明确的专业化），例如：

class Observer {
public:
    virtual void Observe(Parameter p) = 0;
};

template<size_t Tag>
class TaggedObserver : public Observer {
public:
    void Observe(Parameter p) override { }
};

template<std::size_t... I>
class Thing : public TaggedObserver<I>... {
public:
    Thing(): TaggedObserver<I>{}... {}

    template<std::size_t N>
    void Observe(Parameter p) {
        TaggedObserver<N>::Observe(p);
    }
};

然后，您可以将Thing 特化为Thing<0, 1>，并使用thing.Observe<1>(p) 调用正确的函数。

编辑

此编辑的目的是展示一个新的示例代码，即使稍作修改，也或多或少与上述代码相同。
我希望这可以帮助OP。其基本思想是将CRTP习语、虚方法和继承结合起来。

class Observer {
public:
    virtual void Observe(Parameter p) = 0;
};

template<template T, size_t Tag>
class TaggedObserver : public Observer {
public:
    void Observe(Parameter p) override {
        T *t = static_cast<T*>(this);
        // Now use whatever you want from T, that is Thing in this example
    }
};

template<std::size_t... I>
class Thing : public TaggedObserver<Thing<I...>, I>... {
     template<std::size_t J>
     friend class TaggedObserver<Thing<I...>, J>;

public:
    Thing(): TaggedObserver<Thing<I...>, I>{}... {}

    template<std::size_t N>
    void Observe(Parameter p) {
        TaggedObserver<Thing<I...>, N>::Observe(p);
    }
};

注意friend 声明允许TaggedObservers 访问Thing 的私有成员。

这样，TaggedObservers 中的Observe 的实现可以根据 cmets 中的要求访问来自Thing 的公共、受保护和私有成员。

最后你可以根据需要专门化TaggedObserver，从而为Observe提供不同的实现。
举个例子：

template<template T, size_t Tag>
class TaggedObserver;

template<template T>
class TaggedObserver<T, 0>: public Observer {
public:
    void Observe(Parameter p) override {
        T *t = static_cast<T*>(this);
        // Now use whatever you want from T, that is Thing in this example
        // Put here the code of the specialization for Tag 0
    }
};

template<template T>
class TaggedObserver<T, 1>: public Observer {
public:
    void Observe(Parameter p) override {
        T *t = static_cast<T*>(this);
        // Now use whatever you want from T, that is Thing in this example
        // Put here the code of the specialization for Tag 1
    }
};