Errore doppio libero o corruzione

L'errore del doppio libero o della corruzione in C ++ significa che il nostro programma in qualche modo invoca l'oggetto C ++ gratuito () con una variabile di puntatore illegale. Quando utilizziamo puntatori intelligenti come shared_ptr, dobbiamo controllare perché se chiamiamo la funzione get (), stiamo usando direttamente il puntatore grezzo. Abbiamo in programma di assegnarlo a un puntatore intelligente per il continuo riferimento. Questa corruzione è la causa principale dell'incidente del codice. Usiamo la funzione Free () per slogare la memoria heap in genere. La memoria heap ha utilizzato principalmente la funzione del nostro sistema operativo per gestire le posizioni della memoria. Quindi ecco l'errore quando il nostro codice non possiede questo puntatore fino a quando non copriamo il codice.

Quando il puntatore è nullo:

Qui mostriamo solo la nostra funzione gratuita () come funziona all'inizio; Includiamo le librerie e gli standard dello spazio dei nomi e iniziamo il corpo principale del codice inizializzato la variabile intera e inizializzava anche un puntatore con il null per evitare l'errore di doppia corruzione libera o altri puntatori hanno il valore del nostro numero intero. Quindi utilizziamo l'istruzione IF-Else per controllare il puntatore null e il puntatore che ha il nostro valore intero. Dopo la condizione, chiamiamo la nostra funzione per riallocare il nostro puntatore.

#includere
Utilizzo dello spazio dei nomi std;
int main ()

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

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

altro

cout << "Pointer is Null" << endl;

libero (PTR1);
cout << *ptr2;

All'esecuzione, l'output sembrerà così:

Come è maturato:

Questo è maturato se il puntatore utilizza l'allocazione della memoria o chiama la funzione Free () in C ++ direttamente a volte. Potrebbe anche essere maturato quando libero () viene chiamato come argomento nella stessa posizione di memoria una o più di una volta. La struttura dei dati di gestione della memoria del codice è stata danneggiata o non può consentire a un utente finale sospetto di inserire i valori in una posizione di memoria casuale. Se un codice chiama la funzione gratuita () con la stessa posizione di memoria più di una volta.

Inoltre, se eliminiamo la stessa voce due volte ed eliminiamo qualcosa che non è stato assegnato nel mucchio di memoria. Quindi i puntatori sono la causa diretta di questo errore.

#includere
#includere
#includere
int main ()
Std :: Vector vec 0, 1, 2;
Std :: Vector:: iterator it = std :: max_element (vec.inizio (), vec.FINE());
Std :: Vector vec2 3, 4, 5;
Vec.Inserisci (VEC.end (), vec2.inizio (), vec2.FINE());
Vec.cancellalo);
per (auto & n: vec)
std :: cout << n << std::endl;

Innanzitutto, integriamo tre librerie di intestazione; Uno è #include, nella libreria di modelli standard, è una classe modello nel linguaggio di programmazione. È un contenitore di sequenza che salva elementi. Utilizzato principalmente per supportare i dati dinamici nel linguaggio di programmazione C ++. Possiamo espandere i vettori, ma dipende dagli elementi che questi vettori contengono insieme a loro.
Il secondo file di intestazione è #include che ci fornisce molte funzionalità che potrebbero essere per molti scopi, come l'ordinamento dell'elemento, il supporto dell'algoritmo di ricerca, moltiplicando i valori, contando le variabili e così via. Ultimo ma non meno importante, questo è #include che questo scopo è supportare il nostro flusso di input-output. Dopo le biblioteche, iniziamo il nostro corpo principale in cui utilizziamo gli standard con i vettori e assegniamo variabili con tipo di dati interi e assegniamo valori a questa variabile.

Ecco la nostra affermazione in cui assegniamo la nostra variabile insieme al suo inizio ed endpoint attraverso la funzione maz_element. Ripeti di nuovo l'affermazione, ma questa volta cambiamo i nostri valori in un'altra variabile. Quindi utilizziamo la funzione Insert e passiamo i parametri che sono l'endpoint della nostra variabile precedente, il punto di partenza della 2a variabile e l'endpoint della variabile. La funzione cancella () viene utilizzata per cancellare un singolo elemento dal vettore e viene anche utilizzata per modificare la dimensione del vettore. Alla fine, usiamo per loop con il limite della nostra prima variabile e nel ciclo, visualizziamo la variabile che abbiamo inizializzato nel nostro loop.

Come evitare:

Possiamo evitare questo tipo di vulnerabilità; dobbiamo sempre assegnare null al nostro puntatore quando diventa libero. Principalmente i manager heap hanno ignorato i puntatori nulli gratuiti successivamente. Questa è la migliore pratica che annullamo tutti i puntatori cancellati e dobbiamo anche impostare un controllo se il puntatore è nullo o meno prima di liberare il puntatore. Dobbiamo inizializzare il puntatore null all'inizio del nostro codice. Come quando proviamo a usare la dichiarazione Cout (std :: cout).

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int * i = new int ();
Elimina i;
cout<cout<<"\npointer delete successfully";
Elimina i;
cout<restituzione 0;

Il file di intestazione è incluso. Quindi scriviamo usando lo standard dello spazio dei nomi e iniziamo il corpo del programma principale. Abbiamo inizializzato il puntatore con il tipo di dati interi. Qui assegniamo null al puntatore e stampiamo il puntatore. Dopo aver assegnato il null, eliminiamo il puntatore e stampiamo il messaggio di successo. Finalmente, controlliamo di nuovo il nostro puntatore e puoi vedere che non esiste un puntatore nel nostro mucchio di memoria.

Conclusione:

In questo articolo, descriviamo brevemente l'errore doppio o corruzione. Quindi abbiamo riallocato la nostra memoria usando la nostra funzione () e abbiamo discusso delle cause dell'errore e abbiamo usato l'esempio della funzione di cancellazione (). Alla fine, abbiamo fornito una soluzione una soluzione semplice e logica a questo errore in modo molto semplice.