C++ 选择要重写方法的基类

鉴于以下情况：

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

类观察器
{
公众：
虚空观测（参数p）=0；
};
模板
类TaggedObserver:public Observer{}；
类事物：公共TaggedObserver，TaggedObserver
{
公众：
虚拟无效观察（参数p）覆盖；
};

Thing:：Observe

覆盖了

TaggedObserver:：Observe

和

TaggedObserver:：Observe

有没有办法为每个基类提供不同的覆盖？

---

理由：我希望类能够观察相同类型的两个通知源，每个源具有不同的操作，而不必在参数中传递源，然后在

中检查它。如果

/

开关

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

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

或者，你无条件地给他们打电话，让他们知道该怎么做：

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

class TaggedObserverZero:public TaggedObserver
{
公众：
虚空观察（参数p）
{
如果（某些条件）
//做点什么。。。
}
};
类TaggedObserverOne:public TaggedObserver
{
公众：
虚空观察（参数p）
{
如果（其他条件）
//做点别的。。。
}
};
类事物：公共观察者，TaggedObserverZero，TaggedObserverOne
{
公众：
虚空观察（参数p）
{
TaggedObserverZero：：观察（p）；
TaggedObserverOne：：观察（p）；
}
};

在

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

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

注意，

friend

声明允许

TaggedObserver

s访问

Thing

的私有成员

这样，在

TaggedObserver

s中的

Observe

实现可以根据注释中的要求从

Thing

访问公共、受保护和私有成员

最后，如果需要，您可以专门化

TaggedObserver

，以便为

Observe

提供不同的实现
例如：

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

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

模板
类TaggedObserver；
模板
类TaggedObserver:公共观察者{
公众：
无效观察（参数p）超控{
T*T=静态_铸造（本）；
//现在使用你想从T中得到的任何东西，这就是这个例子中的东西
//将标记0的专门化代码放在这里
}
};
模板
类TaggedObserver:公共观察者{
公众：
无效观察（参数p）超控{
T*T=静态_铸造（本）；
//现在使用你想从T中得到的任何东西，这就是这个例子中的东西
//在这里输入标记1的专门化代码
}
};

TaggedObserver

和

TaggedObserver

是同一类。为什么不开设两个儿童班呢？@JimV:他们不是。模板化它们的目的是区分基类。@JimV:

TaggedObserver

和

TaggedObserver

可能基于相同的模板类，但它们是不同的实例化类。例如，就像

std:：vector

和

std:：vector

是不同的类一样。模板参数值是类类型的一部分，并产生不同的RTTI结果。我有一个想法，但到目前为止，它只产生了一个新问题：。P.S。FWIW发布了一个替代解决方案，作为对我相关问题的回答。就像下面@skypjack的回答一样，它使用CRTP将基本的

Observe

重新映射到模板化的

Thing:：Observe

。很好。是否有一种方法可以将

模板void Observe（参数p）

移动到更高的位置，这样就不需要在每一个

类中重复它？这就是我试图做的，但没有找到正确的拼写。我的意图是不能调用不同的
TaggedObserver:：Observe
方法，这已经可以使用
thing->TaggedObserver:：Observe
。我的意图是，
Thing
将对每个
TaggedObserver:：Observe
@Dani具有不同的覆盖，为什么您不能在
TaggedObserver
中定义它们？这样，
东西
将继承这些专门化。也许我误解了这个问题。@skypjack:因为他们需要一些
东西members@Dani答案已更新。如果这对你有帮助，请告诉我。