像这样组合我的对象(作为策略)似乎是一个很好的策略:
template<typename FluxType, typename SourceType>
class Model : public FluxType, public SourceType
{ };
//later in the code:
template<typename FluxType, typename SourceType>
class ConcreteModel : public Model<FluxType, SourceType>
{};
但是,FluxType
和SourceType
是使用相同数据的类。所以我使用了虚拟继承:
class ConcreteModelProps{};
class ConcreteFlux : virtual public ConcreteModelProps
{};
class ConcreteFlux2 : virtual public ConcreteModelProps
{/*sligthly different implementation*/};
class ConcreteSource : virtual public ConcreteModelProps
{};
class DefaultSource2
{/*no need for data*/};
这样我就可以用不同的 FluxType
和 SourceType
对象组合我的 ConcreteModel
。
ConcreteModel<ConcreteFlux, DefaultSource2> /*or whatever*/.
事实是 ConcreteModelProps
中定义的数据与 ConcreteModel
密切相关。在我看来,我至少做错了什么。我怎样才能使这个设计更好?最好没有虚拟继承?
thx, dodol
最佳答案
嗯,很简单:您违反了 LISKOV Substitution Principle让 ConcreteFlux
继承自 ConcreteModelProps
;所以你付出代价是正确的。
现在,如果您外部化数据,您可以使用更健全的模型。
template <typename FluxType, typename SourceType>
class Model {
public:
typedef typename FluxType::DataType DataType;
}; // class Model
template <typename M>
class ConcreteModel: public M {
}; // class ConcreteModel
然后:
class ConcreteFlux {
public:
typedef ConcreteModelProps DataType;
};
class ConcreteSource {
public:
typedef ConcreteModelProps DataType;
};
template <typename Data>
class DefaultSource {
typedef Data DataType;
};
最后:
class ConcreteModel<Model<ConcreteFlux, ConcreteSource>> {};
当然,这意味着现在 ConcreteFlux
和 ConcreteSource
的所有方法都需要在它们的每个方法中将句柄传递给 ConcreteModelProps
。这就是外化的意义所在。
关于c++ - 如何避免虚拟继承,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/14831360/