c++ - 具有额外私有(private)属性的派生类

Question

我想实现一些具有多态性的类层次结构，但我无法让它工作。我有两个问题:

1. 派生类有额外的私有(private)变量
2. 派生类的方法将派生类的对象作为参数并返回派生类的对象。

我可以让这段代码工作，但是是以一种非多态的方式。这是简化版:

class Base
{
protected:
    int mInt;
public: 
    Base(int iValue) : mInt(iValue) {}
    virtual Base operator+(const Base otherBase)
    {
        Base result( otherBase.mInt + mInt);
        return result;
    }

};

class Derived : public Base
{
private:
    double mDouble;
public:
    Derived(int iValue, double dValue) : Base(iValue) 
   {
        mDouble = dValue;
   }
   Derived operator+(const Derived otherDerived)
   {
        Derived result(otherDerived.mInt + mInt,
                       otherDerived.mDouble + mDouble);
        return result;
   }

};

int main()
{

    Derived DobjectA(2,6.3);
    Derived DobjectB(5,3.1);
    Base* pBaseA = &DobjectA;
    Base* pBaseB = &DobjectB;
    // This does not work
    Derived DobjectC = (*pBaseA)+(*pBaseB);

}

我怎样才能设计类来完成这项工作？

Answer 1

这里的关键是将实际对象的类型隐藏在幕后，这样就可以在不知道实际类型的情况下以有意义的方式对其进行操作。

我们需要一些方法来识别我们实际拥有的“东西”的类型:

enum ThingType { TypeA, TypeB } ;

我们需要一个作为接口(interface)的类:

class ThingInterface
{
public:
   /* Type of the object */
   virtual ThingType Type() = 0;
   /* Make a copy of ourselves */
   virtual ThingInterface* Clone() = 0;
   /* Add rhs to this */
   virtual void Add(ThingInterface *rhs) = 0;
   virtual ~ThingInterface();
};

那么我们需要一个支持我们实际操作的类:

class Thing
{
public:
   /* Create empty object */
   Thing(ThingType type) { ... }
   /* Create copy of existing object */
   Thing(ThingInterface* rhs)
   {
       pImpl = rhs->Clone();
   }

   Thing operator+(const Thing& rhs)
   {
       Thing result(pImpl);
       result.pImpl->Add(rhs.pImpl);
       return result;
   }
private:
   ThingInterface *pImpl;
};

现在我们可以实现一些类来做不同类型的事情:

class ThingTypeA: public ThingInterface
{
public:
    ThingTypeA() { ... };
    ThingType Type() { return TypeA; }
    void Clone(ThingInterface *rhs) { ... }
    void Add(ThingInterface *rhs) { ... }
};


class ThingTypeB: public ThingInterface
{
public:
    ThingTypeA() { ... };
    ThingType Type() { return TypeB; }
    void Clone(ThingInterface *rhs) { ... }
    void Add(ThingInterface *rhs) { ... }
};

显然，对于矩阵实现，您需要有一些通用目的“获取单元格 X、Y 的内容”，它在 ThingTypeA 和 ThingTypeB 中实现- 在确定 TypeA + TypeB 等的结果矩阵应该是什么类型时，也许还有一些更聪明的东西。