Question

我想用多态实现一些类的层次结构，我无法使它工作。我有两个问题：

Derived类有额外的私有变量
派生类的方法将派生类的对象作为参数，并返回派生类的对象。

我可以使这个代码工作，但是以非多态的方式。这是简化版本：

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

这里的关键是隐藏幕后实际物体的类型，这样就可以在不知道实际类型的情况下以有意义的方式操作它。

我们需要一些方法来确定什么类型的东西＆＃34;我们实际上有：

enum ThingType { TypeA, TypeB } ;

我们需要一个接口类：

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) { ... }
};

显然，对于矩阵实现，你需要有一些通用的目的＆＃34;让我得到单元格X，Y和＃34;这是在ThingTypeA和ThingTypeB中实现的 - 在确定TypeA + TypeB等结果矩阵的类型时，也可能更聪明一些。

Answer 2

要使问题行有效，您可以使用动态转换：

Derived DobjectC = *(dynamic_cast<Derived*>(pBaseA)) + *(dynamic_cast<Derived*>(pBaseB));

具有额外私有属性的派生类

2 个答案: