Fehler doppelt frei oder Korruption

Der Fehler von doppelter freier oder Korruption in C ++ bedeutet, dass unser Programm auf irgendwie das Free () C ++ - Objekt mit einer illegalen Zeigervariablen aufruft. Wenn wir intelligente Zeiger wie Shared_Ptr verwenden, müssen wir überprüfen. Wir planen, dies einem intelligenten Zeiger für die fortgesetzte Referenz zuzuweisen. Diese Korruption ist die Hauptursache für das Absturz des Codes. Wir verwenden die Funktion Free (), um den Heap -Speicher normalerweise zu verweisen. Der Heap -Speicher hat hauptsächlich die Funktion unseres Betriebssystems verwendet, um die Speicherorte zu verwalten. Hier ist der Fehler, wenn unser Code diesen Zeiger erst besitzt, wenn wir den Code kopieren.

Wenn der Zeiger null ist:

Hier zeigen wir nur unsere Free () -Funktion, wie sie zu Beginn funktioniert. Wir schließen Bibliotheken und Namespace -Standards ein und starten den Hauptteil des Codes initialisierte die Ganzzahlvariable und initialisierte auch einen Zeiger mit dem Null, um den Fehler von doppelter freier oder Korruption zu vermeiden. Dann verwenden wir die IF-ELSE-Anweisung, um den Nullzeiger und den Zeiger mit unserem Ganzzahlwert zu überprüfen. Nach der Bedingung nennen wir unsere Funktion, um unseren Zeiger neu zuzuordnen.

#enthalten
Verwenden von Namespace STD;
int main ()

int x = 5;
int *ptr1 = null;
int *ptr2 = & x;
if (ptr1)

Cout << "Pointer is not Null" << endl;

anders

Cout << "Pointer is Null" << endl;

frei (ptr1);
Cout << *ptr2;

Bei der Ausführung sieht der Ausgang so aus:

Wie es ankommt:

Dies wird aufgelaufen, wenn der Zeiger die Speicherzuweisung verwendet oder die Funktion free () in C ++ direkt direkt aufruft. Es könnte auch aufgenommen werden, wenn Free () als Argument für denselben Speicherort eins oder mehr als einmal bezeichnet wird. Die Speicherverwaltungsdatenstruktur des Codes wurde beschädigt oder kann einem verdächtigen Endbenutzer nicht erlauben, die Werte in einem zufälligen Speicherort einzugeben. Wenn ein Code die Funktion free () mit demselben Speicherort mehr als einmal aufruft.

Wenn wir den gleichen Eintrag zweimal löschen und etwas löschen, das nicht im Speicherhaufen zugewiesen wurde. Somit sind die Zeiger die direkte Ursache für diesen Fehler.

#enthalten
#enthalten
#enthalten
int main ()
STD :: Vektor vec 0, 1, 2;
STD :: Vektor:: iterator it = std :: max_element (vec.begin (), vec.Ende());
STD :: Vektor vec2 3, 4, 5;
vec.Einfügen (vec.end (), vec2.begin (), vec2.Ende());
vec.löschen (es);
für (auto & n: vec)
std :: Cout << n << std::endl;

Zunächst integrieren wir drei Header -Bibliotheken; Einer ist #include, in der Standard -Vorlagenbibliothek ist es eine Vorlagenklasse in der Programmiersprache. Es ist ein Sequenzbehälter, der Elemente spart. Hauptsächlich zur Unterstützung der dynamischen Daten in C ++ - Programmiersprache. Wir können die Vektoren erweitern, aber es hängt von den Elementen ab, die diese Vektoren zusammen mit ihnen enthalten.
Die zweite Header -Datei ist #include, die uns viele Funktionen bietet, die für viele Zwecke sein könnten, z. Zu guter Letzt ist das, dass #include diesen Zweck darin besteht, unseren Eingabebereich zu unterstützen. Nach der Bibliotheken starten wir unseren Hauptteil, in dem wir Standards mit den Vektoren verwenden und Variablen mit ganzzahliger Datentyp zuweisen und dieser Variablen Werte zuweisen.

Hier ist unsere Anweisung, in der wir unsere Variable zusammen mit dem Start und ihrem Endpunkt über die Funktion maz_element zuweisen. Wiederholen Sie diesmal die Anweisung, aber wir ändern unsere Werte diesmal in eine andere Variable. Anschließend verwenden wir die Einfügenfunktion und übergeben die Parameter, die der Endpunkt unserer vorherigen Variablen sind, den Startpunkt der 2. Variablen und den Endpunkt der Variablen. Die Funktion von erase () wird verwendet, um ein einzelnes Element aus dem Vektor zu löschen und auch die Größe des Vektors zu ändern. Endlich verwenden wir für die Schleife mit der Grenze unserer ersten Variablen, und in der Schleife zeigen wir die Variable, die wir in unserer Schleife initialisiert haben.

Wie man vermeidet:

Wir können diese Art von Verwundbarkeit vermeiden. Wir müssen unserem Zeiger immer Null zuweisen, wenn er frei wird. Meistens ignorierten die Haufen Manager die kostenlosen Nullzeiger anschließend. Dies ist die beste Praxis, dass wir alle gelöschten Zeiger null sind, und wir müssen auch überprüft, ob der Zeiger null ist oder nicht, bevor wir den Zeiger befreien. Wir müssen den Zeiger Null zu Beginn unseres Code initialisieren. Zum Beispiel, wenn wir versuchen, Cout (STD :: Cout) zu verwenden.

#enthalten
Verwenden von Namespace STD;
int main ()

int * i = new int ();
i löschen i;
Cout<Cout<<"\npointer delete successfully";
i löschen i;
Cout<Rückkehr 0;

Die Header -Datei ist enthalten. Dann schreiben wir mit dem Namespace -Standard und beginnen den Körper des Hauptprogramms. Wir haben den Zeiger mit dem Ganzzahl -Datentyp initialisiert. Hier weisen wir dem Zeiger Null zu und drucken den Zeiger. Nachdem wir den Null zugewiesen haben, löschen wir den Zeiger und drucken die Erfolgsnachricht aus. Endlich überprüfen wir erneut unseren Zeiger, und Sie können sehen, dass kein Zeiger in unserem Speicherhaufen vorhanden ist.

Abschluss:

In diesem Artikel beschreiben wir kurz den Fehler doppelt frei oder Korruption. Dann haben wir unseren Speicher mit unserer () -Funktion verwendet und die Ursachen des Fehlers diskutiert und das Beispiel der Erasing () -Funktion verwendet. Am Ende haben wir eine Lösung eine einfache und logische Lösung für diesen Fehler auf eine sehr einfache Weise bereitgestellt.