c++ - 基于策略的设计中的模糊继承

Question

我有一个主机类，它采用两个策略，sayhello并且talk. 该策略talk是一个类模板，它本身采用例如sayhello. 问题在于（我试图用 解决这个钻石问题）sayhello::saySomething是模棱两可的。host2virtual

我该如何解决这种歧义？还是一般来说有更好的设计来解决这些问题？

例子：

#include <iostream>

class sayhello {
protected:
    void saySomething(void) {
        std::cout<<"Hello!"<<std::endl;
    }
};

template<typename T>
class talk : private T {
protected:
    void doSomething(void) {
        T::saySomething();
    }
};

template<typename T>
class host1 : virtual T {
public:
    void hostAction(void) {
        T::doSomething();
    }
};

template<typename T, typename L>
class host2 : private T, private L {
public:
    void hostAction(void) {
        T::doSomething();
        L::saySomething();
    }
};

int main() {
    host1<talk<sayhello> > HOST1;
    HOST1.hostAction(); // ok that works

    host2<talk<sayhello>,sayhello> HOST2;
    HOST2.hostAction(); // error, ambiguity!

    return 0;
}

Answer 1

您可能在滥用继承，但只需在and中添加几个virtual关键字：talkhost2

#include <iostream>

class sayhello {
protected:
    void saySomething(void) {
        std::cout<<"Hello!"<<std::endl;
    }
};

template<typename T>
class talk : virtual T {
protected:
    void doSomething(void) {
        T::saySomething();
    }
};

template<typename T>
class host1 : virtual T {
public:
    void hostAction(void) {
        T::doSomething();
    }
};

template<typename T, typename L>
class host2 : virtual T, virtual L {
public:
    void hostAction(void) {
        T::doSomething();
        L::saySomething();
    }
};

int main() {
    host1<talk<sayhello> > HOST1;
    HOST1.hostAction(); // ok that works

    host2<talk<sayhello>,sayhello> HOST2;
    HOST2.hostAction(); // error, ambiguity!

    return 0;
}

现场示例

Answer 2

您可以添加一个虚拟类：

template<typename T> struct dummy : T {};

template<typename T, typename L>
class host2 : private T, private dummy<L> {
public:
    void hostAction(void) {
        T::doSomething();
        dummy<L>::saySomething();
    }
};

在某些情况下，您可能需要L直接转换为，它应该像这样工作：

L& getL()
{
    return static_cast<L&>(static_cast<dummy<L>&>(*this));
}