class C
{
public:
    A n;
    // ...
}

Nun möchte ich eine Klasse D aus C ableiten, in der n nicht vom Typ A, sondern vom Typ B ist. Also ungefähr

class D : public C
{
public:
    B n;
    // ...
}

Wenn ich das allerdings so mache, verfügt D dann sowohl über ein n vom Typ B als auch ein n vom Typ A. Ich möchte aber, dass das n vom Typ A durch das n vom Typ B ersetzt wird und nicht beide nebeneinander existieren. Kann irgendwer was dazu sagen?

Kann irgendwer was dazu sagen?

Ich kann dir sagen, dass das so nicht geht Vererbung ist da, um bestehende Sachen zu erweitern und nicht, um sie zu ersetzen oder zu verändern.

PS: Klassenvariablen sind oft Privatsache

...
Wenn ich das allerdings so mache, verfügt D dann sowohl über ein n vom Typ B als auch ein n vom Typ A. Ich möchte aber, dass das n vom Typ A durch das n vom Typ B ersetzt wird und nicht beide nebeneinander existieren. Kann irgendwer was dazu sagen?

Was du machen kannst ist mit einem Zeiger auf A zu arbeiten, da diesem Zeiger dank Polymorphie auch ein Objekt vom Typ B zugewiesen werden kann. Sofern die Klassen A und B in den Bereichen die du brauchst identliche (virtuelle) Methoden besitzt, musst du auch keinen (langsamen) dynamic_cast einsetzen.

Ungetestet und ohne Fehlerhandling aus dem Kopf geschrieben:

#include <iostream>

class GraphicObject
{
    public:
        virtual GraphicObject();
        virtual Draw() = 0;
};

class Circle : public GraphicObject
{
    public:
        virtual Draw()
        {
            std::cout << "Ein Kreis\n";
        }
};

class Rectangle : public GraphicObject
{
    public:
        virtual Draw()
        {
            std::cout << "Ein Rechteck\n";
        }
        void RectangleSpezific()
        {
            std::cout << "Rechteck spezifische Methode";
        }
};

class C
{
    protected:
        GraphicObject* graphic;

        C(GraphicObject* graphic)
        :  graphic(graphic)
        {}

    public:
        C()
        :  graphic(new Circle())
        {}
        virtual ~C()
        {
            delete graphic;
        }

        virtual void DoSomething1()
        {
            std::cout << "void DoSomething1()\n";
            // ...
            graphic->Draw();
            // ...
        }
};

class D : public C
{
    public:
        D()
        :  C(new Rectangle())
        {}

        void DoSomething2()
        {
            std::cout << "void DoSomething2()\n";
            // ...
            graphic->Draw();
            Rectangle* rectangle = dynamic_cast<Rectangle*>(graphic);
            if(rectangle)
                rectangle->RectangleSpezific();
            // ...
        }
};

int main()
{
    C object1;
    D object2;

    object1.DoSomething1();
    object2.DoSomething1();
    object2.DoSomething2();
}

cu André

Hallo,
ich würde gerne folgendes machen: Sei A eine Klasse und B eine aus A abgeleitete Klasse. Des Weiteren sei

class C
{
public:
    A n;
    // ...
}

Nun möchte ich eine Klasse D aus C ableiten, in der n nicht vom Typ A, sondern vom Typ B ist. Also ungefähr

class D : public C
{
public:
    B n;
    // ...
}

Wenn ich das allerdings so mache, verfügt D dann sowohl über ein n vom Typ B als auch ein n vom Typ A. Ich möchte aber, dass das n vom Typ A durch das n vom Typ B ersetzt wird und nicht beide nebeneinander existieren. Kann irgendwer was dazu sagen?

höre auf die leute, die vor mir gepostet haben.
wenn du das verhalten trotzdem so haben willst, dann:

class C_Interface //Fals du Polymorphie brauchst
{
public:
   virtual void fun () = 0;
   virtual ~C_Interface () {}
};

template <class T>
class C_T : public C_Interface
{
public:
   T n;
};

typedef C_T<A> C;

class Derived : public C_T<B>
{
};

für den fall, dass das objekt in Derived tatsächlich niemals ein A sein soll.