Pointergröße bei Vererbung



  • Hallo,
    ich habe zwei Klassen, von denen eine die Basisklasse der anderen ist.

    class A
    {
        public:
            int avar;
    };
    
    class B : public A
    {
        public:
            double bvar;
    };
    

    Wenn ich jetzt ein neues B-Objekt erstelle, dies aber in einem A-Pointer speichere, wo werden dann die 8 Byte des doubles untergebracht?
    Vor allem bei einem A*-Array, bei dem ich mittendrin ein B* einfüge, müsste das doch Probleme geben 😕


  • Mod

    Ich bin mir nicht sicher, ob du dich nur ungeschickt ausdrückst: Die Pointer selbst sind alle gleich groß. Außerdem kannst du nichts in "Pointern speichern". Du kannst mit Pointern auf eine Stelle zeigen, wo ein Objekt existiert. Wenn du mit einem A-Zeiger auf ein B zeigst, dann ist der Rest vom B trotzdem noch an der Stelle.
    Du kannst auch nicht verschieden große Objekte in einem Array speichern. Wenn du einem A ein B zuweist, dann wird nur der A-Teil des B zugewiesen. Das nennt man dann "splicing".



  • Dein A-Zeiger zeigt auf die Adresse des B-Objektes - das ist möglich, weil ein B automatisch ein A ist. Aber der A-Zeiger hat nur Zugriff auf die A-Elemente im B-Objekt, sodass du einfach keinen Zugriff auf dein bvar hast - es wird einfach ignoriert.

    Stell dir folgendes vor:

    Klasse A
    +------+
    |4 Byte|
    +------+

    Klasse B, von A abgeleitet
    +------+
    |A-Teil|
    |4 Byte|
    +------+
    |B-Teil|
    |8 Byte|
    +------+

    Dein A-Zeiger zeigt zwar auf das ganze B-Objekt, aber Zugriff hat er nur auf den A-Teil. Verstehst du?



  • Wie meinst du das genau?

    Wenn du ein A-Objekt erstellst, dann werden sizeof(A)-Byte im RAM belegt.
    Wenn du ein B-Objekt erstellst, dann werden sizeof(B)-Byte im RAM belegt.
    Wenn du ein 32-bit System hast, benötigt ein Pointer 4 Byte, es werden also 4 Byte im RAM belegt. In diesen 4 Bytes speicherst du nun die Adresse eines Objekts, was zur Folge hat, dass der Pointer auf dieses Objekt zeigt.

    public-Vererbung bedeutet "is-a". In deinem Fall bedeutet das nun, dass jedes B auch ein A ist (nicht umgekehrt!), d.h. dass du selbstverständlich mit einem A-Pointer auf ein B-Objekt zeigen kannst, weil, wie gesagt, B auch ein A ist. Allerdings hat ein A-Pointer nur Informationen zur Klasse A, d.h. du kannst natürlich nur den A-Teil des B-Objektes ansprechen.



  • Typisierte Pointer geben einfach nur an, wie die referenzierte Speicherstelle zu interpretieren ist.



  • Ich hatte einen Denkfehler, dass bei der Zuweisung eines A-Pointers auf ein B-Objekt dieses Objekt verschoben wird.

    Habs jetzt verstanden, danke für die Antworten 🙂


Anmelden zum Antworten