ich möchte eine Basisklasse als referenz übergeben aber der compiler schreit mit Base wurde nicht deklariert:

Base * base;
Derived1 derived1;
Derived2 derived2;
MyClass myclass;

if (bedingung) base = &derived1;
else base = derived2;

myclass.foo(base);

und dann foo

MyClass::foo(Base& base)
{
       base.bar();
}

wo liegt mein fehler - oder geht das nicht?

ich möchte eine Basisklasse als referenz übergeben aber der compiler schreit mit Base wurde nicht deklariert:

Dem Compiler würde ich an dieser Stelle einfach glauben. Der kennt die Sprache, zumindest die syntaktischen Regeln, wahrscheinlich besser als Du.

Dein Programmfetzen sieht gut aus. Es müsste möglich sein, wenn das "drumherum" auch stimmt. Das "drumherum" hast Du uns aber nicht gezeigt.

#include <iostream>

class Mtx
{
        public:
         void To_Pattern() {
          std::cout << "ToPattern" << std::endl;       
         };             
};

// die main
class Base
{
        public:
               virtual void bar() = 0;       
};
class D1 : public Base
{
        public:
                void bar() {
                std::cout << "D1:Base" << std::endl;
                mtx.To_Pattern();
                };
                Mtx mtx;
};
class D2 : public Base
{
        public:       
                void bar() {
                    std::cout << "D2:Base" << std::endl;
                    mtx.To_Pattern();
                };
                Mtx mtx;
};

class MyClass
{
        public: 
          void foo(Base* base) {
                 base->bar();
                }
};

int main(int argc, char** argv)
{
        Base * base = NULL;
        D1 d1;
        D2 d2;

        base = &d1;

        MyClass myclass;
        myclass.foo(base);

        return 0;
}

JETZT will ich aber in MyClass this (also sich selbt) verändern und möchte damit in Methode To_Pattern in Klasse Mtx ein Objekt vom Typ MyClass haebn - nur wie erreiche ich das?

ich versuche es vergeblich so:

#include <iostream>

class Mtx
{
        public:
                MyClass* To_Pattern() {
          std::cout << "ToPattern" << std::endl;       
          MyClass * myclass = new MyClass();
          //mach was mit myclass und gibs zurück
          return myclass;
         };             
};

// die main
class Base
{
        public:
                virtual MyClass* bar() = 0;       
};
class D1 : public Base
{
        public:
                MyClass* bar() {
                std::cout << "D1:Base" << std::endl;
                return mtx.To_Pattern();
                };
                Mtx mtx;
};
class D2 : public Base
{
        public:       
                MyClass* bar() {
                    std::cout << "D2:Base" << std::endl;
                    return mtx.To_Pattern();
                };
                Mtx mtx;
};

class MyClass
{
        public: 
          void foo(Base* base) {
                 this = base->bar();
                }
};

int main(int argc, char** argv)
{
        Base * base = NULL;
        D1 d1;
        D2 d2;

        base = &d1;

        MyClass myclass;
        myclass.foo(base);

        return 0;
}

this = base->bar();

geht nicht, weil this ist const, man kann "this" keine andere Adresse zuweisen.
So was macht man aber auch echt nicht!

P.S.: Dein jetziges "Problem" deckt sich nicht mit der anfangs angedeuteten (und nicht geposteten) Fehlermeldung.

a) Nicht immer einen neuen thread aufmachen wenn das problem rein passt. Klar ists was anderes - aber ich kann den titel nicht mehr ändern.

b) Ich soll funktionierendes minimalbeispiel posten. Habe ich getan.

Und jetzt störts schon wieder also bitte....

Back to topic:

Kann ich denn sowas machen:

base->bar(this);

und dann this verändern. geht wohl auch nicht oder?

Falls nicht: Wie kann ich mein Problem beheben? Ich will in der Klasse ein Objekt verändern über eine Andere klasse. Unsauber?

Kann ich denn sowas machen:

base->bar(this);

und dann this verändern. geht wohl auch nicht oder?

this ist auch da nicht veränderbar!
Du kannst natürlich sehrwohl non-const Methoden darauf aufrufen, aber du kannst this keine andere Adresse zuweisen! Egal wie du das drehen willst!

Falls nicht: Wie kann ich mein Problem beheben? Ich will in der Klasse ein Objekt verändern über eine Andere klasse. Unsauber?

Indem du einfach nicht versuchst ein Objekt such selbst ändern zu lassen. Ergo gehört das außerhalb von deiner Instanz gemacht, egal wie und egal wo.
Bedenke, dass wenn du einem Pointer einen neuen "Wert" gibst, es also auf ein anderes Objekt zeigen lässt, das vorher referenzierte Objekt nicht mehr über diesen pointer zugänglich ist. Wenn also der Pointer der einzige ist, der auf das Objekt zeigt, musst (!) du ihn mit delete löschen, um ein Speicherleck zu verhindern.

[OT]
Du brauchst Mtx nicht für dein Beispiel, ebenso keine verschiedenen Ableitungen von Base für ein Minimalbeispiel. Da muss man erst ewig durch den schlecht eingerückten Texkt suchen um deine Klassen und Methoden zu finden. (Setze "Ewig" in den zeitlichen Rahmen, den man sich eines Problems annehmen "will".)
Und das wichtigste ist einfach die Fehlermeldung, die du uns in diesem Post bisher vollkommen vorenthalten hast. Es bringt A) nichts, einen Codefetzen hinzuknallen, der vollkommen frei ohne Kontext im Raum steht, viel Code zu posten, den man erst kompilieren muss um überhaupt zu erahnen, welchen Fehler du bekommen haben könntest.
Denn erfahrene Augen sehen anhand der Fehlermeldung meist schon welches Problem du hast. Aer eben nicht immer...

Dazu muss bar lediglich einen Zeiger auf MyClass erhalten:

class Base
{
        public:
               virtual void bar(MyClass* m) = 0;      
};

btw:
Schlecht eingerückt ist es und das solltest du schon richtig machen. Die IDE deiner Wahl unterstützt dich dabei enorm.

Und das hier:

MyClass* To_Pattern() {
          std::cout << "ToPattern" << std::endl;      
          MyClass * myclass = new MyClass();
          //mach was mit myclass und gibs zurück
          return myclass;
         };

ist böse. Du erzeugst da einen Zeiger und gibst ihn nie wieder frei. Sprich der User von To_Pattern müsste das machen, was in deinem Code aber nie geschieht. Grundsätzlich sollte immer derjenige, der Speicher explizit anfordert den auch wieder freigeben.

@Lästermaul:

this ist auch da nicht veränderbar!
Du kannst natürlich sehrwohl non-const Methoden darauf aufrufen, aber du kannst this keine andere Adresse zuweisen! Egal wie du das drehen willst!

Du scheinst da etwas zu verwechseln. this ist ein konstanter Zeiger auf ein nichtkonstantes Objekt (wenn er aus einem nichtkonstantem Objekt kommt).

#include <iostream>

class Pattern
{
    public: 
         void foo(Base& base)
         {
             base.To_Pattern(this);
         }
};

// die main
class Base
{
  public:
          virtual void To_Pattern(Pattern*& P) = 0;       

};
class D1 : public Base
{
    public:
        void To_Pattern(Pattern *& P) 
        {
            std::cout << "D1:Base" << std::endl;
            //auf P arbeiten
        }
};
class D2 : public Base
{
    public:       
        void To_Pattern(Pattern*& P) 
        {
            std::cout << "D2:Base" << std::endl;
            // auf P arbeiten
        }
};

int main(int argc, char** argv)
{
        Base * base = NULL;
        D1 d1;
        D2 d2;
        base = &d1;
        MyClass myclass;
        myclass.foo(base);
        return 0;
}

Die compiler-meldung ist:

Fehler: »Base« wurde nicht deklariert
main.cpp: In member function »void Pattern::foo(int&)«:
main.cpp:13: Fehler: Abfrage des Elementes »To_Pattern« in »base«, das vom Nicht-Klassentyp »int« ist
main.cpp: In function »int main(int, char**)«:
main.cpp:49: Fehler: »MyClass« wurde in diesem Gültigkeitsbereich nicht definiert
main.cpp:49: Fehler: expected `;' before »myclass«
main.cpp:50: Fehler: »myclass« wurde in diesem Gültigkeitsbereich nicht definiert

Vor der Base reicht eine Vorwärtsdeklaration von Pattern.
(Siehe auch hier)

#include <iostream>

class Pattern
{
    public: 
         void foo(Base* base)
         {
             base->To_Pattern(this);
         }
};

// die main
class Base
{
  public:
          virtual void To_Pattern(Pattern*& P) = 0;       

};
class D1 : public Base
{
    public:
        void To_Pattern(Pattern *& P) 
        {
            std::cout << "D1:Base" << std::endl;
            //auf P arbeiten
        }
};
class D2 : public Base
{
    public:       
        void To_Pattern(Pattern*& P) 
        {
            std::cout << "D2:Base" << std::endl;
            // auf P arbeiten
        }
};

int main(int argc, char** argv)
{
        Base * base = NULL;
        D1 d1;
        D2 d2;
        base = &d1;
        Pattern pat;
        pat.foo(base);
        return 0;
}

mit folgender meldung:

g++ -o out main.cpp
main.cpp:7: Fehler: »Base« wurde nicht deklariert
main.cpp: In member function »void Pattern::foo(int*)«:
main.cpp:9: Fehler: Abfrage des Elementes »To_Pattern« in »* base«, das vom Nicht-Klassentyp »int« ist
main.cpp: In function »int main(int, char**)«:
main.cpp:46: Fehler: keine passende Funktion für Aufruf von »Pattern::foo(Base*&)«
main.cpp:7: Anmerkung: Kandidaten sind: void Pattern::foo(int*)

Ich bitte nochmals um folgende betrachtung:

//Pattern.h

#ifndef My_H
#define My_H

#include "Base.h"

class Pattern
{
        public: 
                void foo(Base* base)
                {
                        base->To_Pattern(this);
                }
};

#endif

//Base.h

#ifndef Bs_H
#define Bs_H

#include "Pattern.h"

// die main
class Base
{
        public:
                virtual void To_Pattern(Pattern*& P) = 0;       

};

#endif

//D1.h

#ifndef D1_H
#define D1_H

#include "Pattern.h"
#include "Base.h"

class D1 : public Base
{
        public:
                void To_Pattern(Pattern *& P) 
                {
                        std::cout << "D1:Base" << std::endl;
            //auf P arbeiten
                }
};

#endif

//D2.h

#ifndef D2_H
#define D2_H

#include "Pattern.h"
#include "Base.h"

class D2 : public Base
{
        public:       
                void To_Pattern(Pattern*& P) 
                {
                        std::cout << "D2:Base" << std::endl;
            // auf P arbeiten
                }
};

#endif

//Main.cpp

#include "Base.h"
#include "Pattern.h"
#include "D1.h"
#include "D2.h"

int main(int argc, char** argv)
{
        Base * base = NULL;
        D1 d1;
        D2 d2;
        base = &d1;
        Pattern pat;
        pat.foo(base);
        return 0;
}

Mit folgender meldung:

Pattern.h:10: Fehler: »Base« wurde nicht deklariert
Pattern.h: In member function »void Pattern::foo(int*)«:
Pattern.h:12: Fehler: Abfrage des Elementes »To_Pattern« in »* base«, das vom Nicht-Klassentyp »int« ist
main.cpp: In function »int main(int, char**)«:
main.cpp:22: Fehler: keine passende Funktion für Aufruf von »Pattern::foo(Base*&)«
Pattern.h:10: Anmerkung: Kandidaten sind: void Pattern::foo(int*)

Einzige Lösung:
Dein "main.cpp" in verschieden Header (.h) und Implementiereungen (.cpp) aufteilen. Dann reicht im Header eine Forward-Deklaration, im .cpp wird dann der jeweils andere Header mit includiert.
Im Prinzip sollte es reichen, Pattern von den restlichen Klassen zu separieren.

@Drakon:
Danke!

Fehler: Als linker Operand einer Zuweisung wird L-Wert erfordert

kommt wenn ich "this = new Test;" versuche.
An eine Funktion das this übergeben macht aber keine Probleme! Das hatte ich so nicht erwartet.
Aber funktionieren tut es nur, wenn das Objekt mit "new" erstellt wurde. Sonst -> SegFault!

Interessant fand ich auch, dass das Objekt an der selben Stelle im Speicher erstellt wurde! Egal ob vorher delete oder nicht!

#include <iostream>
using namespace std;

struct Test;
void modify(Test*);

struct Test
{
    int num;
    void modifyThis()
    {
        num = 3;
        cout << this << endl;
        modify(this);
        cout << num << endl;
    }
    ~Test()
    {
        cout << "destroy " << this << endl;
    }
};

void modify(Test* t)
{
    cout << "modifiy " << t << endl;
    delete t; // Auskommentieren, dann verschwindet der Segfault, die Adresse ändert sich nicht!
    t = new Test;
}

int main()
{
    Test* t = new Test;
    t->modifyThis();
    cout << "*** " << t << endl;
    Test t3;
    t3.modifyThis(); // <== Segfault!!!
}

Also Vorsicht beim Überschreiben des this-Pointers.

Einzige Lösung:
Dein "main.cpp" in verschieden Header (.h) und Implementiereungen (.cpp) aufteilen. Dann reicht im Header eine Forward-Deklaration, im .cpp wird dann der jeweils andere Header mit includiert.
Im Prinzip sollte es reichen, Pattern von den restlichen Klassen zu separieren.

aj aj aj...ich überlege wie ich das ändern kann weil mir der lösungsvorschlag zu aufwändig/seltsam ist. Evtl. ist bei mir falsches design die grundlage...

hmm...

An eine Funktion das this übergeben macht aber keine Probleme! Das hatte ich so nicht erwartet.
Aber funktionieren tut es nur, wenn das Objekt mit "new" erstellt wurde. Sonst -> SegFault!

Nein, nein, nein. Du verstehst das etwas völlig falsch!

void modify(Test* t) // hier wird der this Zeiger kopiert
{
    cout << "modifiy " << t << endl;
    delete t; // das ist ganz klar böse, wenn du ein automatisches Objekt hast
    t = new Test; // das weist t einen neuen Zeiger zu und nicht dem Objekt, auf welches t vorher gezeit hat.
}

Ich hoffe du verstehst das jetzt, ansonsten muss ich wirklich auch noch mit ASCII Art anfangen. :p

Base.h

#ifndef BASE_H
#define BASE_H

class Pattern;

class Base 
{ 
    public: 
        virtual void To_Pattern(Pattern* P) = 0;
};

class D : public Base 
{ 
    public: 
        void To_Pattern(Pattern * P);
};

#endif

Base.cpp

#include <iostream>

#include "Base.h"
#include "Pattern.h"

void D::To_Pattern(Pattern * P)
{
    std::cout << "D1:Base" << std::endl; 
    //auf P arbeiten 
}

Pattern.h

#ifndef PATTERN_H
#define PATTERN_H

class Base;

class Pattern 
{ 
    public:
        void foo(Base* base);
}; 

#endif

Pattern.cpp

#include "Pattern.h"
#include "Base.h"

void Pattern::foo(Base* base)
{ 
    base->To_Pattern(this); 
}

main.cpp

#include "Base.h"
#include "Pattern.h"

int main(int argc, char** argv) 
{
    Base * base = 0; 
    D d1;
    base = &d1; 
    Pattern pat; 
    pat.foo(base); 
    return 0; 
}

Kompilieren:

$ g++ -c Pattern.cpp
$ g++ -c Base.cpp
$ g++ main.cpp -o main Base.o Pattern.o
$ ./main

void modify(Test* t) // hier wird der this Zeiger kopiert
{
    cout << "modifiy " << t << endl;
    delete t; // das ist ganz klar böse, wenn du ein automatisches Objekt hast
    t = new Test; // das weist t einen neuen Zeiger zu und nicht dem Objekt, auf welches t vorher gezeit hat.
}

In der letzten Zeile dein Kommentar:
Ich habe auch gedacht, dass t nun auf ein neues Objekt, was ja definitiv an einer anderen Stelle im Speicher liegen müsste, zeigt.
Die ganzen Test-Ausgaben vor, während und nach dem Modify zeigen mir in dem Fall aber ein anderes Bild:

0x603010
modifiy 0x603010
destroy 0x603010
0
*** 0x603010

Es ist IMMER die selbe Adresse, demnach wird die selbe Speicherstelle überschrieben... Oder bin ich da jetzt wieder total daneben?

Ein späteres

t = new Test;
cout << t << endl;
t = new Test;
cout << t << endl;

liefert wie erwartet

0x603030
0x603050

void modify(Test* t) // hier wird der this Zeiger kopiert
{
    cout << "modifiy " << t << endl;
    delete t; 
    t = new Test; 
    cout << "modifyed t: " << t << endl;
    delete t; // jetzt auch wieder aufräumen
}

Du kannst t ja gar nicht kennen ausserhalb der Funktion.. Du hast klar immer den gleichen Wert ausgegeben.

...
        cout << this << endl; (1)
        modify(this); (2)
    }
    ~Test()
    {
        cout << "destroy " << this << endl; (3)
    }
...

0x603010 (1)
modifiy 0x603010 (2) (innerhalb von modify)
destroy 0x603010 (3)
0 ??
*** 0x603010 ??

Mit dem obigen Code müsste zwischen 2 und 3 ein anderer Zeiger ausgegeben werden.

#include <iostream>
using namespace std;

struct Test;
void modify(Test*);

struct Test
{
    void modifyThis()
    {
        cout << "=== Test::modifiyThis() (this == " << this << ") === " << endl;
        modify(this);
        cout << "after modify() " << this << endl;
        cout << "======" << endl;
    }
    ~Test()
    {
        cout << "destroy " << this << endl;
    }
};

void modify(Test* t)
{
    cout << "modifiy " << t << endl;
    delete t;
    t = 0;
    t = new Test;
    cout << "modified t: " << t << endl;
    delete t;
}

int main()
{
    Test* t = new Test;
    t->modifyThis();
    cout << "*** " << t << endl;
    delete t;
}

Das finale "delete t" in modify() beschert mir einen segfault beim finalen delete in main()...
Ebenso wie ein weiterer Aufruf von modifyThis().
Ich find das lustig, weil ich ohne weiteres noch mit dem Objekt arbeiten konnte, auf Member zugreifen usw. aber ein zweites delete geht in die Hose.

Außerdem, egal an welcher Stelle ich noch die Adresse ausgeben lasse (in Test::modifyThis(), modify() oder main()), immer ist es die Selbe...

Du kannst t ja gar nicht kennen ausserhalb der Funktion.. Du hast klar immer den gleichen Wert ausgegeben.

Hmm, ich kann doch belibig Zeiger kopieren und dann vergleichen, das sollte bei egal wie gearteten Aufrufen bei gleichen Adressen das gleiche Ergebnis liefern.
Ob ich in einer Memberfunktion jetzt "this" mit einem übergebenen Pointer vergleiche oder zwei Pointer in einer freien Funktion oder direkt, oder ...

Ich glaub ich muss da nochmal drüber schlafen...
Vllt. küsst mich die Erkenntnis ja noch

Grüße und Danke

#include <iostream>
using namespace std;

struct Test;
void modify(Test*);

struct Test
{
    void modifyThis()
    {
        cout << "=== Test::modifiyThis() (this == " << this << ") === " << endl;
        modify(this);
        cout << "after modify() " << this << endl;
        cout << "======" << endl;
    }
    ~Test()
    {
        cout << "destroy " << this << endl;
    }
};

void modify(Test* t)
{
    cout << "modifiy " << t << endl; // ok, gibt das gleiche, wie this
    //delete t; // böse, böse böse! 
    t = 0; // ok
    t = new Test; // ok
    cout << "modified t: " << t << endl; //ok, sollte was anderes ausgeben
    delete t; // ok
}

int main()
{
    Test* t = new Test; // ok
    t->modifyThis(); //ok
    cout << "*** " << t << endl; //ok, gibt das gleiche, wie this
    delete t; // wenn das innere delete aktiviert ist, wird hier der speicher erneut zerstört und das gibt den fehler!
}

Das finale "delete t" in modify() beschert mir einen segfault beim finalen delete in main()...

Das ist nicht verwunderlich, der Speicher wurde ja bereits freigegeben.

Lästermaul schrieb:

Ich find das lustig, weil ich ohne weiteres noch mit dem Objekt arbeiten konnte, auf Member zugreifen usw. aber ein zweites delete geht in die Hose.

Ziehe keine Schlüsse aufgrund solcher Aktionen. Sobald ein Objekt zerstört wurde, resultiert der Zugriff darauf in undefiniertem Verhalten. Das bedeutet, es ist reines Glück, falls das Programm abstürzt.

Lästermaul schrieb:

Hmm, ich kann doch belibig Zeiger kopieren und dann vergleichen, das sollte bei egal wie gearteten Aufrufen bei gleichen Adressen das gleiche Ergebnis liefern.
Ob ich in einer Memberfunktion jetzt "this" mit einem übergebenen Pointer vergleiche oder zwei Pointer in einer freien Funktion oder direkt, oder ...

Du übergibst eben eine Kopie des Zeigers, deshalb führt das t = new Test; in modify() nicht dazu, dass der originale Zeiger neu zugewiesen wird. Der this -Zeiger kann nämlich nicht verändert werden.

Lies Dir mal _genau_ durch was "by Value" bedeutet. Wenn Du erinen Zeiger by Value übergibst (was Du bei deinem Methodenaufruf nunmal machst) dann wird für den Scope der Methode ein temporärer Zeiger angelegt. Alle Veränderungen des Zeigers innerhalb der methode (new, delete etc) finden NUR auf diesem temporären Zeiger statt und sind daher außerhalb der Methode nicht relevant.

Natürlich können mehrere Zeiger auf das gleiche Objekt im Speicher zeigen, weist Du aber einem der Zeiger mittels new ein neues Objekt zu, hat das _keine_ Auswirkung auf die anderen Zeiger die nach wie vor auf das alte Objekt zeigen.

Um die Änderung am Zeiger innerhalb der Methode auch außerhalb sichtbar zu machen mußt Du den Zeiger "by Reference" übergeben, als sowas in der Art:

void modify(Test*& t)
{
}

Lästermaul schrieb:

Ich find das lustig, weil ich ohne weiteres noch mit dem Objekt arbeiten konnte, auf Member zugreifen usw. aber ein zweites delete geht in die Hose.

Ziehe keine Schlüsse aufgrund solcher Aktionen. Sobald ein Objekt zerstört wurde, resultiert der Zugriff darauf in undefiniertem Verhalten. Das bedeutet, es ist reines Glück, falls das Programm abstürzt.

Und genau das denk ich mir schon die ganze Zeit!!! Undefiniertes Verhalten.
Dann ist der Kommentar von loks bezügl. delete auf eine Kopie eines Zeigers auch falsch. Ich bin erleichtert!

Du übergibst eben eine Kopie des Zeigers, deshalb führt das t = new Test; in modify() nicht dazu, dass der originale Zeiger neu zugewiesen wird. Der this -Zeiger kann nämlich nicht verändert werden.

Dass man this (den this-Zeiger) nicht ändern kann, hab ich doch auch gesagt, trotzdem wurde mir wiedersprochen
Das mit der Kopie des Zeigers ist mir jetzt auch klar.
Werd mir das nochmal in Ruhe anschauen, ob ich das alles jetzt richtig begreife...

Du musst unterscheiden zwischen dem Zeiger als Objekt an sich und dem Speicherbereich, auf den er zeigt.

int* a = new int(4);
int* b = a;   // beide Zeiger zeigen auf 4
delete b;     // gibt die angeforderte Vier frei
b = 0;        // a ist nun NICHT Null.

Wenn du einen Zeiger als Value-Parameter übergibst, d.h. void modify(Test* t) , ist das eine Kopie, wie hier im Beispiel b . Änderungen am Speicherbereich dahinter sind von ausserhalb der Funktion sichtbar, Änderungen am Zeiger selbst jedoch nicht. Und zu letzteren gehört nun mal t = new Test .

loks hat schon Recht.
[...]

Wenn du einen Zeiger als Value-Parameter übergibst, d.h. void modify(Test* t) , ist das eine Kopie, wie hier im Beispiel b . Änderungen am Speicherbereich dahinter sind von ausserhalb der Funktion sichtbar, Änderungen am Zeiger selbst jedoch nicht. Und zu letzteren gehört nun mal t = new Test .

loks schrieb:

Alle Veränderungen des Zeigers innerhalb der methode (new, delete etc) finden NUR auf diesem temporären Zeiger statt und sind daher außerhalb der Methode nicht relevant.

Die allgemeine Formulierung ist aber irreführend.
Es mag sein dass das delete für den Zeiger (!) außerhalb von modify() irrelevant ist. Trotzdem ist es im Allgemeinen nicht irrelevant, denn das delete verändert vllt. nicht den Zeiger, aber den Speicherbereich - Das Objekt auf welches der Zeiger zeigt wird gelöscht. Ab hier sind Zugriffe auf das Objekt undefiniert.