多重继承:调用所有覆盖的函数

Question

我有几个我希望类具有的行为。我想隔离这些行为，以便我可以重用该代码，随意混合和匹配。

例如，执行此操作的一种方法是：

class BehaviorAbstract {
protected:
virtual void processInfo(Info i) = 0;
}
class Behavior1: public BehaviorAbstract {
protected:
virtual void processInfo(Info i) { ... }
void performBehavior1()  { ... }
}
class Behavior2: public BehaviorAbstract {
protected:
virtual void processInfo(Info i) { ... }
void performBehavior2()  { ... }
}
class ConcreteObject: public Behavior1, Behavior2 {
protected:
void processInfo(Info i) {
// needs to call processInfo of Behavior1 and Behavior2
Behavior1::processInfo(i);
Behavior2::processInfo(i);
}
void perform() {
this->performBehavior1(); this->performBehavior2();
}
}

所以这就是问题的症结：ConcreteObject需要调用它继承的所有类的 2 个函数processInfo(相同的名称，相同的参数)。假设所有行为类都由不同的开发人员编码。该函数必须具有相同的名称，因为它们都派生自 BehaviorAbstract。

这样做的合理设计模式是什么？我怀疑多重继承在这里可能是错误的，也许"多重组合"会更好，但我需要从BehaviorAbstract派生的所有Behavior类和ConcreteObject，并且它们都需要对BehaviorAbstract的同一受保护数据成员进行操作。

我上面写的解决方案感觉是错误的和丑陋的。有没有办法自动调用所有实现 processInformation 的父类，而无需显式重写它们的名称？

非常感谢您的帮助。

Answer 1

如果我做对了，那么这个问题就是关于重构ConcreteObject类。

方法#1：

如果你能performBehavior()BehaviorAbstract基类的一部分，那么你就可以简单地使用BehaviorAbstract*向量，让多态性做它的事情。我认为这可以看作是战略模式。

#include <iostream>
#include <vector>
typedef int Info;
struct BehaviorAbstract
{
virtual void processInfo(Info i) = 0;
virtual void performBehavior() = 0;
};
struct Behavior1 : BehaviorAbstract 
{
void processInfo(Info i) override
{ std::cout<< "Behavior1::processInfo()" <<std::endl; }
void performBehavior() override
{ std::cout<< "Behavior1::performBehavior()" <<std::endl; }
};
struct Behavior2 : BehaviorAbstract
{
void processInfo(Info i) override
{ std::cout<< "Behavior2::processInfo()" <<std::endl; }
void performBehavior() override
{ std::cout<< "Behavior2::performBehavior()" <<std::endl; }
};
//------------------------------------------------//
struct ConcreteObject
{
typedef std::vector<BehaviorAbstract*> vec_behavior;
vec_behavior vba;
ConcreteObject(vec_behavior &&v) : vba(v)
{;}
void processInfo(Info i)
{
for (auto &&itr : vba)
itr->processInfo(i);
}
void perform()
{
for (auto &&itr : vba)
itr->performBehavior();
}
};
int main()
{
ConcreteObject foo = {{new Behavior1(), new Behavior2()}};
foo.processInfo(23);
foo.perform();
}

示例：https://rextester.com/UXR42210

方法#2：

使用创建元组的可变参数模板。迭代该元组并运行函数。同样，如果performBehavior1()和performBehavior2()可以共享相同的函数名称，那么它会变得更容易。这里的额外复杂性是您需要编写一种手动迭代该元组的方法。为简单起见，我直接从iterate_tuple结构调用了processInfo()。

#include <iostream>
#include <tuple>
typedef int Info;
struct BehaviorAbstract
{
virtual void processInfo(Info i) = 0;
};
struct Behavior1 : BehaviorAbstract 
{
void processInfo(Info i) override
{ std::cout<< "Behavior1::processInfo()" <<std::endl; }
void performBehavior1()
{ std::cout<< "Behavior1::performBehavior1()" <<std::endl; }
};
struct Behavior2 : BehaviorAbstract
{
void processInfo(Info i) override
{ std::cout<< "Behavior2::processInfo()" <<std::endl; }
void performBehavior2()
{ std::cout<< "Behavior2::performBehavior2()" <<std::endl; }
};

//------------------------------------------------//
template<typename T, std::size_t N>
struct iterate_tuple 
{
static void run(T &t, Info i) 
{
std::get<N>(t).processInfo(i); 
iterate_tuple<T, N-1>::run(t,i); 
}
}; 
template<typename T>
struct iterate_tuple<T, 0> 
{
static void run(T &t, Info i) 
{
std::get<0>(t).processInfo(i); 
}
};
//------------------------------------------------//
template<typename ...T>
struct ConcreteObject
{
std::tuple<T ...> tmp;
static constexpr std::size_t tuple_size = std::tuple_size<decltype(tmp)>::value;
ConcreteObject() : tmp{std::forward<T>(T()) ...}
{;}
void processInfo(Info i)
{
iterate_tuple<decltype(tmp), tuple_size-1>::run(tmp, i);
}
void perform()
{
std::get<0>(tmp).performBehavior1();
std::get<1>(tmp).performBehavior2();
}
};

int main()
{
ConcreteObject<Behavior1,Behavior2> foo;
foo.processInfo(23);
foo.perform();
}

示例：https://rextester.com/SBRE16218

这两种方法都避免了多重继承，据我所知，这是您想要避免的。仅供参考，越简单越好。