New und Delete



  • Sehr geehrte Community,

    erstmal Danke im Voraus dafür, dass ihr mir bei meinem Problem weiterhelft.ü

    Momentan beschäftige ich mich mit dem Heap. Ich hab gelesen, dass man mit (new) Speicher reservieren kann.

    Der soll wohl so lange belegt bleiben, bis mit (delete) wieder alles gelöscht wird. Er soll auch noch belegt bleiben, wenn der Gültigkeitsbereich verlassen wird.

    Jetzt aber das Problem:

    void Funktion()
    {
    int *pZeiger = NULL;
    pZeiger = new int;
    }

    int main()
    {
    Funktion();

    // Nun müsste man pZeiger doch auch in der Main-Funktion
    // irgendwie verwenden können, da der Speicher doch noch auf dem
    // Heap drauf ist. Doch genau hier weiß ich nicht, wie ich das mache.

    delete pZeiger; // hier kommt eine Fehlermeldung. Obwohl doch eigentlich
    // der Speicher noch auf dem Heap drauf sein sollte

    return 0;
    }

    Danke im Voraus für die Hilfe

    Freundliche Grüße



  • Natürlich kannst du dein mit new erzeugtes Objekt dann in main() verwenden, du musst es eben nur in main() irgendwie bekannt machen (z.B. indem du Funktion() einen Zeiger auf das erzegte Objekt returnen lässt). Im Moment legst du in Funktion() ein Objekt mit new an. Wenn Funktion() returned dann wird pZeiger zerstört und damit geht dein einziger Zeiger auf das Objekt verloren. Das Objekt existiert dann zwar weiter aber du hast keinen Zeiger mehr drauf (Memory Leak). Dass du bei delete pZeiger; in main() einen Fehler bekommst ist doch ganz klar, pZeiger ist in main() ja nicht bekannt, ist ja eine lokale Variable in Funktion()...



  • Dein Denkfehler liegt an einer anderen Stelle. Schau dir mal an, wann eine Variable sichtbar, d.h. gültig, ist. Deine Schlüsse zu new und delete sind aber richtig. Als Hinweis noch, wenn du mit new Arrays anforderst, dann musst du delete [] nehmen. Das ist Pflicht! Und niemals malloc() und delete, bzw. new und free() mischen. Das können zwei völlig verschiedene Funktionen sein.



  • Variante 1 (verwendet eine globale Variabel, daher sehr schlecht!):

    #include <iostream>
    #include <cstdio>
    
    int *pZeiger = NULL;
    
    void Funktion()
    {
    	pZeiger = new int;
    }
    
    int main()
    {
    	Funktion();
    
    	delete pZeiger;
    
    	return 0;
    }
    

    Variante 2:

    #include <iostream>
    #include <cstdio>
    
    void Funktion(int **pZeiger)
    {
    	*pZeiger = new int;
    }
    
    int main()
    {
    	int *p;
    
    	Funktion(&p);
    
    	delete p;
    
    	return 0;
    }
    

    Variante 3:

    #include <iostream>
    #include <cstdio>
    
    int *Funktion()
    {
    	int *pZeiger = new int;
    
    	return pZeiger;
    }
    
    int main()
    {
    	int *p = Funktion();
    
    	delete p;
    
    	return 0;
    }
    


  • New und Delete sollten möglichst zusammen gehören. Wenn man die Funktion als Blackbox betrachtet, dann weis man nicht sicher ob dort ein new Aufgerufen wurde oder nicht, d.h. man weis nicht ob man noch ein delete braucht, bzw. vergisst es schnell. In c++ ist es daher üblich Klassen zu verwenden, diese können dann im Konstruktur new verwenden und im Destruktor delete, dann wird auch nix vergessen.
    (Es sei denn man vergisst das delete im Destruktor).



  • Danke für die schnelle Hilfe,

    ihr seid echt Spitze!

    ich hab jetzt die Problematik hinter dem Script verstanden. Man muss unterscheiden zwischen dem Zeiger auf das Objekt und dem Objekt selber.

    Hab jetzt die Alternativen ausprobiert und es funktioniert einwandfrei.


Anmelden zum Antworten