Производный класс с дополнительными частными атрибутами

Question

Я хочу реализовать некоторую иерархию классов с полиморфизмом, и я не могу заставить его работать. У меня есть две проблемы:

1. производный класс имеет дополнительные частные переменные
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 } ; 

Нам нужен класс, который является интерфейсом:

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; 
}; 

И теперь мы можем реализовать некоторый класс, чтобы сделать различные типы O е вещь:

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 и т.д.

Answer 2

Чтобы сделать работу проблема строки, вы можете использовать динамическое приведение:

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