Deepcopy und Vererbung



  • Hi,

    ich stehe vor folgendem Problem:

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    class Parent
    {
    public:
        virtual void id() { cout << "Parent\n" ; }
    };
    
    class Child: public Parent
    {
    public:
        virtual void id() { cout << "Child\n"; }
    };
    
    class ParentHolder
    {
    public:
        ParentHolder() {};
        ParentHolder(const ParentHolder &cpy) {
            for(int i = 0; i < 10; i++)
                holder.push_back(new Parent(*cpy.holder[i]));
        }
    
        vector<Parent *> holder;
    };
    
    int main() {
        ParentHolder holder;
    
        for(int i = 0; i < 10; i++)
            holder.holder.push_back(new Child());
    
        ParentHolder holder2(holder);
    
        cout << "Holder: \n";
        for(int i = 0; i < 10; i++)
            holder.holder[i]->id();
    
        cout << "Holder2: \n";
        for(int i = 0; i < 10; i++)
            holder2.holder[i]->id();
    
        for(int i = 0; i < 10; i++)
        {
            delete holder.holder[i];
            delete holder2.holder[i];
        }
    
        return 0;
    }
    

    Die Ausgabe ist folgende:
    Holder:
    Child
    Child
    Child
    Child
    Child
    Child
    Child
    Child
    Child
    Child
    Holder2:
    Parent
    Parent
    Parent
    Parent
    Parent
    Parent
    Parent
    Parent
    Parent
    Parent

    Ich finde es ja verständlich, dass der Typ in holder2 Parent ist. Doch wie schaffe ich es, dass beim kopieren die Vererbung weitergegeben wird?
    Oder ist in diesem Fall einfach kein Deepcopy möglich, und ich muss, um die Vererbung beizubehalten, auf deepcopy verzichten?

    Danke im Voraus



  • Neronus schrieb:

    holder.push_back(new Parent(*cpy.holder[i]));
    

    Was erwartes du denn, du erstellst doch selber Parents.

    was dir helfen könnte wäre etwas in dieser art:

    class Parent
    {
    public:
        virtual Parent* clone()
        {
         Parent p = new Parent();
         //Daten zuweisen
         return p;
        }
    };
    
    class Child : public Parent
    {
    public:
        virtual Child* clone()
        {
         Child *c = new Child();
         //Daten zuweisen
         return c;
        }
    }
    
    class Parentholder
    {
    public:
        Parentholder(const Parentholder& cpy)
        {
         for(int i = 0; i < 10; i++)
                holder.push_back(cpy.holder[i]->clone() );
        }
    //...
    }
    

    Vieleicht weiß jemand anderes eine bessere Möglichkeit.


Log in to reply