2

我之前已经发布过这个问题（这里），这是一种不同的解决方案。这个解决方案似乎更好地封装了那些实现类的行为，因为它可以防止他们需要显式地向上转换。

这是问题所在：

我有一个项目，我想在其中隔离大多数对象的核心行为，同时通过派生对象提供额外的行为。很简单：

class BaseA
{
    virtual void something() {}
}


class DerivedA : public BaseA
{
    void something() {}
    void somethingElse() {}
}

现在假设我还有第二组类，相同的继承方案，只是它们聚合了上述类。但是，我希望基版本使用基类，派生版本在派生类中。我的解决方案我正在考虑使用相同的名称“隐藏”基类变量；

class BaseB
{
    BaseA *var;

    BaseB()
    {
        var = new BaseA();
    }

    virtual void anotherThing1();
    virtual void anotherThing2();
    virtual void anotherThing3();
}

class DerivedB : public BaseB
{
    DerivedA *var;

    DerivedB()
    {
        var = new DerivedA();
    }

    void anotherThing1();
    void anotherThing2();
    void anotherThing3();
    void andAnother1();
    void andAnother2();
}

这种方法的目标是使依赖于派生聚合类的函数不再需要显式转换来实现获得的功能。

void func1( BaseB &b )
{
    b.anotherThing1();
    b.var->something();
}

void func2( DerivedB &b )
{
    b.anotherThing1();
    b.andAnother1();
    b.var->something();
    b.var->somethingElse();
}

void main( int argc, char **argv )
{
    BaseB    baseB;
    DerivedB derivedB;

    func1( baseB );
    func1( derivedB );
    func2( derivedB );
}

这会被认为是不好的做法吗？

4

1 回答 1

1

这会被认为是不好的做法吗？

是的，这将是不好的做法，因为varinBase将未被使用。它看起来不DerivedB应该派生自BaseB: 相反，它们应该派生自同一个抽象基类，如下所示：

class AbstractB {
public:
    virtual void anotherThing1() = 0;
    virtual void anotherThing2() = 0;
    virtual void anotherThing3() = 0;
};
class DerivedB1 : public AbstractB { // Former BaseB
    BaseA *var;

public:
    DerivedB1() {
        var = new BaseA();
    }
    virtual void anotherThing1();
    virtual void anotherThing2();
    virtual void anotherThing3();
};
class DerivedB2 : public AbstractB { // Former DerivedB
    DerivedA *var;
public:
    DerivedB2() {
        var = new DerivedA();
    }
    void anotherThing1();
    void anotherThing2();
    void anotherThing3();
    void andAnother1();
    void andAnother2();
};

这里使用的一般原则是您应该尝试将继承层次结构中的所有非叶类抽象化。

于 2013-07-09T15:42:49.033 回答