Einstellen Variable auf NULL nach frei

StackOverflow https://stackoverflow.com/questions/1025589

Frage

In meiner Firma gibt es eine Codierung Regel, die besagt, nachdem jede Speicherfreigabe, setzen die Variable auf NULL. Zum Beispiel ... 

void some_func () 
{
    int *nPtr;

    nPtr = malloc (100);

    free (nPtr);
    nPtr = NULL;

    return;
}

Ich glaube, dass in Fällen wie den oben angezeigten Code ein, auf NULL Einstellung keine Bedeutung hat. Oder bin ich etwas fehlt?

Wenn es keine Bedeutung in solchen Fällen ist, werde ich es mit dem „Qualitätsteam“ zu übernehmen diese Codierung Regel zu entfernen. Bitte Rat.

War es hilfreich?

Lösung

nicht verwendeten Zeigers auf NULL Einstellung ist ein defensiver Stil, den Schutz gegen baumelnden Zeiger Fehler. Wenn ein baumelnden Zeiger zugegriffen wird, nachdem es freigegeben wird, können Sie zufällige Speicher gelesen oder überschrieben werden. Wenn ein Null-Zeiger zugegriffen wird, erhalten Sie einen sofortigen Absturz auf den meisten Systemen erhalten, können Sie sofort zu sagen, was der Fehler ist.

Für lokale Variablen kann es ein bisschen sinnlos, wenn es „offensichtlich“ ist, dass der Zeiger nicht mehr zugegriffen wird nach freigegeben wird, so dass dieser Stil ist besser geeignet für die Mitgliedsdaten und globale Variablen. Auch für lokale Variablen, kann es ein guter Ansatz sein, wenn die Funktion auch nach dem Speicher freigegeben wird.

, um den Stil zu vervollständigen, sollten Sie auch Zeiger auf NULL initialisiert werden, bevor sie einen echten Zeigerwert zugewiesen bekommen.

Andere Tipps

einen Zeiger Einstellung nach NULL free ist eine zweifelhafte Praxis, die oft als „gute Programmierung“ Regel auf einem offensichtlich falschen Prämisse populär ist. Es ist eine jener falschen Wahrheiten, die auf die „klingt richtig“ Kategorie gehören, aber in der Realität erreichen absolut nichts brauchbares (und manchmal führt zu negativen Folgen).

Angeblich Einstellung einen Zeiger auf NULL nach free soll die gefürchteten „Double Free“ -Problem verhindern, wenn der gleiche Zeigerwert übergeben wird mehr free als einmal. obwohl, in 9 von 10 Fällen das eigentliche „Double Free“ Problem tritt in der Realität, wenn andere Zeiger Objekte den gleichen Zeigerwert halten werden als Argumente für free verwendet. Unnötig zu sagen, NULL einen Zeiger Einstellung nach free absolut nichts erreicht, das Problem in solchen Fällen zu verhindern.

Natürlich ist es möglich, in „Double Free“ Problem zu laufen, wenn das gleiche Zeiger-Objekt als Argument verwenden free. Jedoch zeigt in Wirklichkeit Situationen wie das normalerweise ein Problem mit der allgemeinen logischen Struktur des Codes, nicht nur ein zufälligen „Double Free“. Eine richtige Art und Weise mit dem Problem in solchen Fällen umzugehen ist, zu überprüfen und die Struktur des Codes, um die Situation zu überdenken, wenn der gleiche Zeiger zu vermeiden, übergibt mehr als einmal free. In solchen Fällen den Zeiger Einstellung NULL und in Anbetracht des Problems „fixiert“ ist nichts anderes als ein Versuch, das Problem unter den Teppich zu kehren. Es wird einfach nicht im allgemeinen Fall arbeiten, weil das Problem mit der Codestruktur wird immer einen anderen Weg finden, um sich zu manifestieren.

Schließlich, wenn Ihr Code speziell stützen sich auf den Zeigerwert ist NULL oder nicht NULL ausgebildet ist, ist es völlig in Ordnung, den Zeigerwert einzustellen, nach NULL free. Aber als allgemeiner „good practice“ -Regel (wie in „immer gesetzt den Zeiger nach NULL free“) ist es, wieder einmal, ein bekanntes und ziemlich nutzlos fake, oft von einigen gefolgt für rein religiöse, Voodoo-ähnlichen Gründe .

Die meisten Antworten haben sich auf eine doppelte frei zu verhindern, aber den Zeiger auf NULL Einstellung hat einen weiteren Vorteil. Sobald Sie einen Zeiger freizugeben, ist, dass der Speicher verfügbar durch einen anderen Aufruf von malloc umverteilt werden. Wenn Sie immer noch die ursprünglichen Zeiger haben um Sie mit einem Fehler könnten am Ende, wo Sie den Zeiger nach freier und korrupten einer anderen Variable zu verwenden versuchen, und dann geht das Programm einen unbekannten Zustand und alle Arten von schlechten Dingen passieren können (Absturz, wenn Sie ‚Glück hat, zur Beschädigung von Daten, wenn Sie Pech haben). Wenn Sie den Zeiger auf NULL nach frei gesetzt hatte, jeder Versuch zum Lesen / Schreiben durch diesen Zeiger später in einem segfault führen würde, die in der Regel vorzuziehen, um zufällige Speicherbeschädigung ist.

Aus beiden Gründen kann es eine gute Idee sein, den Zeiger auf NULL nach frei zu setzen (). Es ist nicht immer notwendig, though. Zum Beispiel, wenn die Zeigervariable geht out of scope unmittelbar nach free (), gibt es nicht viel Grund, es auf NULL zu setzen.

Dies ist eine gute Praxis als Speicher nicht überschrieben. In der obigen Funktion ist es nicht notwendig, aber oft, wenn es fertig ist es Fehler in der Anwendung finden kann.

Versuchen Sie so etwas wie diese stattdessen: 

#if DEBUG_VERSION
void myfree(void **ptr)
{
    free(*ptr);
    *ptr = NULL;
}
#else
#define myfree(p) do { void ** __p = (p); free(*(__p)); *(__p) = NULL; } while (0)
#endif

Die DEBUG_VERSION können Sie frees Profil Code in das Debuggen, aber beide sind funktional gleich.

Bearbeiten . Hinzugefügt do ... while wie unten vorgeschlagen, dank

Wenn Sie Zeiger erreichen, die frei gewesen () d hat, könnte es brechen oder nicht. Dieser Speicher könnte zu einem anderen Teil des Programms neu zugewiesen werden und Sie dann Speicherfehler bekommen,

Wenn Sie den Zeiger auf NULL gesetzt, dann, wenn Sie darauf zugreifen, stürzt das Programm immer mit einem segfault. Nicht mehr ,, manchmal funktioniert es ‚‘, nicht mehr ,, Abstürze in unpredictible Weg ‚‘. Es ist viel einfacher zu debuggen.

, um den Zeiger auf den free'd Speichereinrichtung einstellen, dass jeder Versuch, dass der Speicher durch den Zeiger zuzugreifen sofort abstürzen, sondern nicht definiertes Verhalten verursachen. Es macht es viel einfacher, um zu bestimmen, wo die Dinge schief gelaufen ist.

kann ich Ihr Argument sehen: da nPtr ist außerhalb des Gültigkeitsbereichs gehen direkt nach nPtr = NULL, da kein Grund zu sein scheint es auf NULL. im Falle eines struct Mitglied jedoch oder irgendwo anders, wo der Zeiger nicht unmittelbar außerhalb des Gültigkeitsbereichs gehen wird, macht es mehr Sinn. Es ist nicht sofort ersichtlich, ob dieser Zeiger wird wieder von Code verwendet werden, die es nicht verwenden sollte.

Es ist wahrscheinlich die Regel ist, ohne eine Unterscheidung zwischen diesen beiden Fällen festgestellt, weil es viel schwieriger ist, automatisch die Regel durchzusetzen, geschweige denn für die Entwickler es zu folgen. Es tut nicht weh Zeiger setzen nach jedem frei NULL, aber es hat das Potenzial, große Probleme hingewiesen.

die häufigste Fehler in c ist die doppelte frei. Im Grunde tun Sie etwas wie die 

free(foobar);
/* lot of code */
free(foobar);

und es ist ziemlich schlecht am Ende, versuchen Sie das Betriebssystem einige bereits freigegebenen Speicher zu befreien und im Allgemeinen segfault es. So ist die gute Praxis zu NULL setzen, so dass Sie Test machen und überprüfen, ob Sie auch wirklich diese Speicher müssen frei 

if(foobar != null){
  free(foobar);
}

auch darauf hingewiesen werden, dass free(NULL) werde nichts tun, so dass Sie die if-Anweisung nicht schreiben müssen. Ich bin nicht wirklich ein Guru OS, aber ich bin ziemlich schon jetzt die meisten Betriebssysteme auf doppelte frei abstürzen würde.

Das ist auch ein Hauptgrund, warum alle Sprachen mit Garbage Collection (Java, Dotnet) war so stolz auf dieses Problem nicht mit und hat auch nicht an die Entwickler die Speicherverwaltung als Ganzes zu verlassen.

Die Idee dahinter ist versehentliche Wiederverwendung des befreiten Zeiger zu stoppen.

Das (kann) tatsächlich wichtig sein. Auch wenn Sie den Speicher frei, könnte ein späterer Teil des Programms etwas Neues zuweisen, die in dem Raum zu landen geschieht. Ihre alte Zeiger würden jetzt auf einen gültigen Teil des Speichers verweisen. Es ist dann möglich, dass jemand den Zeiger verwenden würde, was zu ungültigem Programmzustand.

Wenn Sie den Zeiger NULL, dann jeder Versuch, es zu benutzen zu dereferenzieren 0x0 und Crash genau dort wird, die zum Debuggen einfach ist. Zufällige Zeiger zeigt auf gelegentliches Gedächtnis ist schwer zu debuggen. Es ist natürlich nicht notwendig, aber dann das ist, warum es in einem Best Practices-Dokument ist.

Von dem ANSI-C-Standard: 

void free(void *ptr);
  

Die freie Funktion bewirkt, dass der Raum   auf den ptr zeigt ausgeplant werden,   das heißt, zur weiteren verfügbar   Zuweisung. Wenn ptr ein Nullzeiger ist,   keine Aktion stattfindet. Andernfalls, wenn die   Argument entspricht nicht einen Zeiger   zuvor von der calloc zurückgekehrt,   malloc oder realloc Funktion, oder wenn   der Raum wurde durch eine ausgeplant   rufen oder realloc zu befreien, das Verhalten   nicht definiert ist.

„das undefinierte Verhalten“ ist fast immer ein Programmabsturz. Um dies zu vermeiden, ist es sicher, die Zeiger auf NULL zurückgesetzt. free () selbst kann dies nicht tun, da es nur einen Zeiger übergeben wird, nicht einen Zeiger auf einen Zeiger. Sie können auch eine sicherere Version von free () schreiben, die NULL-Werte den Zeiger: 

void safe_free(void** ptr)
{
  free(*ptr);
  *ptr = NULL;
}

Das finde ich wenig Hilfe wie in meiner Erfahrung sein, wenn die Menschen eine befreite Speicherzuordnung zugreifen es fast immer ist, weil sie einen anderen Zeiger auf sie irgendwo haben. Und dann in Konflikt mit einem anderen persönlichen Codierungsstandard, die „Vermeiden nutzlos Unordnung“ ist, so dass ich es nicht tun, wie ich denke, es hilft nur selten und macht den Code etwas weniger lesbar.

Allerdings - ich werde nicht die Variable auf null gesetzt, wenn der Zeiger nicht wieder verwendet werden soll, aber oft das höhere Level-Design gibt mir einen Grund, es zu setzen ohnehin auf null. Zum Beispiel, wenn der Zeiger ist ein Mitglied einer Klasse und ich habe gelöscht, was er zeigt, dann wird der „Vertrag“, wenn Sie wie die Klasse ist, dass das Mitglied, um etwas zu jeder Zeit gültig Punkt wird also festgelegt werden muss auf null aus diesem Grund. Ein kleiner Unterschied, aber ich denke, ein sehr wichtiger.

In C ++ ist es wichtig, immer zu denken, die besitzt diese Daten, wenn Sie etwas Speicher zuweisen (es sei denn, Sie intelligente Zeiger verwenden, aber selbst dann ist einige Gedanken erforderlich). Und dieser Prozess neigt dazu, Zeiger im Allgemeinen als Mitglied einer Klasse zu führen und in der Regel wollen Sie eine Klasse jederzeit in einem gültigen Zustand zu sein, und der einfachste Weg, das zu tun ist, um die Membervariable zu setzen, um anzuzeigen, auf NULL es Punkte zu nichts mehr.

Ein übliches Muster ist im Konstruktor alle Mitglieds Zeiger auf NULL zu setzen und die Destruktoraufrufs auf alle Zeiger auf Daten löschen, die Ihr Design sagt, dass Klasse besitzt . Offensichtlich in diesem Fall müssen Sie den Zeiger auf NULL setzen, wenn Sie etwas löschen, um anzuzeigen, dass Sie keine Daten besitzen vor.

Um es zusammenzufassen, ja ich oft den Zeiger auf NULL gesetzt, nachdem etwas zu löschen, aber es ist als Teil einer größeren Design und Gedanken darüber, wer die Daten besitzt, anstatt aufgrund blind Standard-Regel nach einer Codierung. Ich würde nicht so in Ihrem Beispiel tun, wie ich glaube, es gibt keinen Nutzen für die so tun, und sie fügt hinzu: „Unordnung“, die in meiner Erfahrung für Fehler und schlechten Code wie diese Art der Sache ebenso verantwortlich ist.

Vor kurzem komme ich über die gleiche Frage, nachdem ich nach der Antwort gesucht. Ich kam zu dieser Schlussfolgerung:

Am besten ist es Praxis, und man muss diese folgen, um es auf allen (embedded) Systeme tragbar zu machen.

free() ist eine Bibliotheksfunktion, die als eine der Plattform ändert sich ändert, so dass Sie sollten nicht erwarten, dass Zeiger auf diese Funktion nach dem Passieren und nach freigegeben werden kann, wird dieser Zeiger auf NULL gesetzt werden. Dies kann nicht der Fall für einige Bibliothek für die Plattform implementiert sein.

so immer gehen für 

free(ptr);
ptr = NULL;

Diese Regel ist nützlich, wenn Sie versuchen, die folgenden Szenarien zu vermeiden:

1) Sie haben eine wirklich lange Funktion mit komplizierter Logik und Speicherverwaltung, und Sie wollen nicht versehentlich die Zeiger auf gelöschte Speicher wieder zu verwenden später in der Funktion.

2) Der Zeiger ist eine Membervariable einer Klasse, die ziemlich komplexes Verhalten hat, und Sie wollen nicht versehentlich in anderen Funktionen die Zeiger auf gelöschte Speicher wieder zu verwenden.

In Ihrem Szenario wird es nicht viel Sinn machen, aber wenn die Funktion mehr zu bekommen, könnte es eine Rolle.

Sie können argumentieren, dass es auf NULL Einstellung tatsächlich später Maske auf Fehler Logik kann, oder in dem Fall, in dem Sie annehmen, dass es gültig ist, noch Sie auf NULL abstürzen, so dass es keine Rolle spielt.

Im Allgemeinen würde ich Ihnen raten, es auf NULL zu setzen, wenn Sie denken, es ist eine gute Idee, und nicht die Mühe, wenn Sie denken, es ist es nicht wert. Konzentrieren Sie sich stattdessen auf kurze Funktionen Schreiben und gut gestaltete Klassen.

, um hinzuzufügen, was andere gesagt haben, eine gute Methode der Zeiger Nutzung ist immer zu prüfen, ob es ein gültiger Zeiger ist oder nicht. So etwas wie: 


if(ptr)
   ptr->CallSomeMethod();

Markierung Explizit den Zeiger als NULL nach Freigabe es für diese Art der Nutzung in C / C ++ ermöglicht.

Dies könnte mehr ein Argument alle Zeiger auf NULL zu initialisieren, aber so etwas wie dies kann ein sehr hinterhältiger Fehler sein: 

void other_func() {
  int *p; // forgot to initialize
  // some unrelated mallocs and stuff
  // ...
  if (p) {
    *p = 1; // hm...
  }
}

void caller() {
  some_func();
  other_func();
}

p endet an der gleichen Stelle auf dem Stapel als ehemaliges nPtr oben, so könnte es noch einen scheinbar gültigen Zeiger enthält. Zuweisen zu *p könnte alle Arten von nicht verwandten Dingen zu überschreiben und zu hässlich Bugs führen. Vor allem, wenn die Compiler lokale Variablen mit Null im Debug-Modus initialisiert hat aber nicht einmal Optimierungen eingeschaltet sind. So baut die Debug zeigt keine Anzeichen der Fehler während Veröffentlichung zufällig sprengen baut ...

Stellen Sie den Zeiger, der gerade auf NULL befreit hat, ist nicht obligatorisch, aber eine gute Praxis. Auf diese Weise können Sie 1) unter Verwendung eines vermeiden befreit 2 zeigte) frei, es towice

Einstellungen ein Zeiger auf NULL ist agains zu schützen sogenannte Doppelfrei -. Eine Situation, free () mehr als einmal für die gleiche Adresse aufgerufen wird, ohne an dieser Adresse den Block Neuzuweisung

Double frei führt zu undefinierten Verhalten - Heap in der Regel Korruption oder das Programm sofort abstürzt. Der Aufruf free () für einen NULL-Zeiger tut nichts und wird daher als sicher gewährleistet.

So ist die beste Praxis, wenn Sie jetzt sicher, dass der Zeiger Umfang verlässt sofort oder sehr bald nach frei () ist, dass die Zeiger so zu setzen, auf NULL, dass selbst wenn freie () aufgerufen, wieder es jetzt einen NULL-Zeiger aufgerufen wird und nicht definiertes Verhalten wird umgangen.

Die Idee ist, dass, wenn Sie versuchen, zu dereferenzieren des Nicht-mehr-Zeiger gültig, nachdem sie zu befreien, Sie wollen hart (segfault) zum Scheitern verurteilt, anstatt still und geheimnisvoll.

Aber ... vorsichtig sein. Nicht alle Systeme verursachen eine segfault wenn Sie dereferenzieren NULL. On (zumindest einige Versionen von) AIX, * (int *) 0 == 0 und Solaris verfügt über optionale Kompatibilität mit diesem AIX "Funktion."

Um die ursprüngliche Frage: Einstellen die Zeiger auf NULL direkt nach dem Inhalt zu befreien eine komplette Zeitverschwendung ist, sofern der Code alle Anforderungen erfüllt, voll ausgetestet und wird nie wieder verändert werden. Auf der anderen Seite, die Verteidigung einen Zeiger nulling, die nützlich ganz befreit worden sein kann, wenn jemand fügt gedankenlos einen neuen Codeblock unter dem freien (), wenn das Design des Original-Modul nicht korrekt ist, und in dem Fall davon -compiles-but-Passt nicht-do-was-ich-will Bugs.

In jedem System gibt es ein unerreichbares Ziel es am einfachsten das Richtiges zu machen, und die nicht reduzierbar Kosten für ungenaue Messungen. In C sind wir eine Reihe von sehr scharf, sehr starken Werkzeugen angeboten, die viele Dinge in den Händen eines Facharbeiters erstellen kann, und alle Arten von metaphorischen Verletzungen verursachen, wenn sie unsachgemäß behandelt. Einige sind schwer zu verstehen oder richtig zu verwenden. Und die Menschen, ist natürlich risikoavers, tun irrationale Dinge wie einen Zeiger für NULL-Wert überprüft, bevor sie mit ihm frei telefonieren ...

Das Messproblem ist, dass, wenn Sie versuchen, gut zu teilen von weniger gut ist, desto komplexer Fall, desto wahrscheinlicher werden Sie eine mehrdeutige Messung erhalten. Wenn das Ziel nur gute Praktiken do zu halten ist, dann einig mehrdeutig diejenigen mit der Darstellung des eigentlich nicht gut geworfen. Wenn Ihr Ziel ist das nicht gut zu beseitigen ist, dann können die Mehrdeutigkeiten mit dem guten Aufenthalt. Die beiden Ziele, halten nur gut oder beseitigen eindeutig schlecht, scheint diametral entgegengesetzt werden, aber es ist in der Regel eine dritte Gruppe, die weder das eine noch das andere ist, die beide einige.

Bevor Sie einen Fall mit der Abteilung Qualitätssicherung machen, versucht, durch die Bug Datenbank schauen, um zu sehen, wie oft, wenn überhaupt, ungültige Zeigerwerte Probleme verursacht, die nach unten werden mußten geschrieben. Wenn Sie wirklich etwas machen wollen, identifizieren die am häufigsten auftretende Problem in Ihrem Produktionscode und schlägt drei Möglichkeiten, es zu verhindern

Es gibt zwei Gründe:

Abstürze vermeiden, wenn doppelt Befreiung

Geschrieben von: RageZ in einem doppelte Frage .

  

Der häufigste Fehler in c ist die doppelte   kostenlos. Im Grunde tun Sie so etwas wie   dass 

free(foobar);
/* lot of code */
free(foobar);
     

und es ist ziemlich schlecht am Ende, das Betriebssystem versuchen   einige bereits freigegebenen Speicher zu befreien und   allgemein segfault es. Die gute   Praxis ist NULL gesetzt, so dass Sie   machen Test und prüfen Sie, ob Sie wirklich   müssen diese Speicher frei 

if(foobar != NULL){
  free(foobar);
}
     

auch, dass free(NULL) anzumerken,   wird nichts tun, so dass Sie nicht haben   schreiben die if-Anweisung. Ich bin nicht   wirklich ein OS-Guru, aber ich bin ziemlich sogar   jetzt sind die meisten OSes würde auf Doppel abstürzen   frei.

     

Das ist auch ein Hauptgrund, warum alle   Sprachen mit Garbage Collection   (Java, Dotnet) war so stolz auf nicht   mit diesem Problem und auch nicht   mit an Entwickler verlassen den   Speicherverwaltung als Ganzes.

Vermeiden Sie die Verwendung der bereits freigegeben Zeiger

Geschrieben von: Martin v Löwis in einem another Antwort .

  

Einstellung nicht verwendeten Zeigers auf NULL ist ein   defensiver Stil, den Schutz vor   baumelnden Zeiger Fehler. Wenn ein baumelnden   Zeiger zugegriffen wird, nachdem er freigegeben wird,   Sie können statistische lesen oder überschreiben   Erinnerung. Wenn ein Null-Zeiger zugegriffen wird,   Sie erhalten einen sofortigen Absturz auf den meisten   Systeme, Sie sofort zu sagen, was   der Fehler ist.

     

Für lokale Variablen kann es sein, ein   wenig sinnlos, wenn es   „Offensichtlich“, dass der Zeiger nicht   zugegriffen mehr nach befreit wird, so   Dieser Stil ist besser geeignet für   Mitgliedsdaten und globale Variablen. Sogar   für lokale Variablen, kann es eine gute sein   Ansatz, wenn die Funktion weiter   nachdem der Speicher freigegeben wird.

     

, um den Stil zu vervollständigen, sollten Sie auch   initialisieren Zeiger auf NULL vor   sie bekommen einen echten Zeiger zugewiesen   Wert.

Wie Sie ein Qualitätssicherungsteam eingerichtet haben, lassen Sie mich einen kleinen Punkt über QA hinzufügen. Einige automatisierte QA-Tools für C Willen Flagge Zuweisungen befreit Zeiger als „nutzlos Zuordnung ptr“. Zum Beispiel PC-lint / FlexeLint von Gimpel Software sagt tst.c 8 Warning 438: Last value assigned to variable 'nPtr' (defined at line 5) not used

Es gibt Möglichkeiten, Nachrichten selektiv unterdrücken, so dass Sie immer noch beide QA Anforderungen erfüllen, sollte so Ihr Team entscheiden.

Es ist immer ratsam, eine Zeigervariable mit NULL wie

zu erklären, 
int *ptr = NULL;

Lassen Sie uns sagen, ptr zeigt auf 0x1000 Speicheradresse. Nach der Verwendung von free(ptr), dann ist es immer ratsam, die Zeigervariable auf NULL , indem er erklärt wieder zunichte zu machen. z. 

free(ptr);
ptr = NULL;

Wenn nicht neu deklariert NULL , die Zeigervariable hält nach wie vor auf Hinweis auf die gleiche Adresse ( 0x1000 ), dieser Zeigervariable heißt eine baumelnden Zeiger . Wenn Sie eine andere Zeigervariable definieren (sagen wir mal, q ) und dynamisch-Adresse an den neuen Zeiger zuweisen, gibt es eine Chance, die gleiche Adresse unter ( 0x1000 ) durch neue Zeiger Variable. Wenn im Fall verwenden Sie den gleichen Zeiger ( ptr ) und den Wert an der Adresse, die von den gleichen Zeigern ( ptr ), dann wird das Programm am Ende schreibt eine spitze aktualisieren Wert an den Ort, an dem q zeigt (da p und q auf die gleiche Adresse zeigen ( 0x1000 ) ).

z. 

*ptr = 20; //Points to 0x1000
free(ptr);
int *q = (int *)malloc(sizeof(int) * 2); //Points to 0x1000
*ptr = 30; //Since ptr and q are pointing to the same address, so the value of the address to which q is pointing would also change.

Lange Rede kurzer Sinn: Sie wollen nicht versehentlich (versehentlich) die Adresse zugreifen, die Sie freigegeben haben. Denn wenn Sie die Adresse freizugeben, Sie erlauben diese Adresse in dem Heap zu einer anderen Anwendung zugeordnet werden.

Wenn Sie jedoch nicht setzen den Zeiger auf NULL, und versehentlich versuchen, den Zeiger de-Referenz oder den Wert dieser Adresse ändern; Sie können immer noch tun. Aber nicht etwas, Sie würden LOGISCH tun wollen.

Warum kann ich immer noch Zugriff auf den Speicherplatz, die ich befreit haben? Denn: Sie können frei haben den Speicher, aber die Zeigervariable hatte noch Informationen über die Heap-Speicher-Adresse. So, als eine defensive Strategie, fügen Sie es auf NULL gesetzt.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top