Erreur double libre ou corruption

L'erreur de double libre ou de corruption en C ++ signifie que notre programme invoque en quelque sorte l'objet libre () C ++ avec une variable de pointeur illégal. Lorsque nous utilisons des pointeurs intelligents tels que Shared_ptr, nous devons vérifier car si nous appelons la fonction get (), nous utilisons directement le pointeur brut. Nous prévoyons d'attribuer cela à un pointeur intelligent pour référence continue. Cette corruption est la cause profonde de l'écrasement du code. Nous utilisons la fonction libre () pour disloquer généralement la mémoire du tas. La mémoire du tas a principalement utilisé la fonction de notre système d'exploitation pour gérer les emplacements de la mémoire. Voici donc l'erreur lorsque notre code ne possède pas ce pointeur avant de copier le code.

Lorsque le pointeur est nul:

Ici, nous montrons simplement notre fonction gratuite () comment cela fonctionne au début; Nous incluons des bibliothèques et des normes d'espace de noms et démarrer le corps principal du code initialisé la variable entière et a également initialisé un pointeur avec le null pour éviter l'erreur de double libre ou de corruption et d'autres pointeurs ont la valeur de notre entier. Ensuite, nous utilisons l'instruction IF-ELSE pour vérifier le pointeur nul et le pointeur qui a notre valeur entière. Après la condition, nous appelons notre fonction pour réaffecter notre pointeur.

#inclure
Utilisation de Namespace Std;
int main()

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

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

autre

couter << "Pointer is Null" << endl;

gratuit (ptr1);
couter << *ptr2;

Lors de l'exécution, la sortie ressemblera à ceci:

Comment c'est l'accumulation:

Ceci est accumulé si le pointeur utilise l'allocation de mémoire ou appelle la fonction libre () en C ++ directement parfois. Il pourrait également être accumulé lorsque libre () est appelé comme argument au même emplacement de mémoire une ou plus d'une fois. La structure de données de gestion de la mémoire du code est devenue corrompue ou ne peut pas permettre à un utilisateur final suspect de saisir les valeurs dans un emplacement de mémoire aléatoire. Si un code appelle la fonction libre () avec le même emplacement de mémoire plus d'une fois.

De plus, si nous supprimons la même entrée deux fois et supprimons quelque chose qui n'a pas été alloué dans le tas de mémoire. Ainsi, les pointeurs sont la cause directe de cette erreur.

#inclure
#inclure
#inclure
int main()
STD :: Vector vec 0, 1, 2;
STD :: Vector:: iterator it = std :: max_element (vec.begin (), vec.fin());
STD :: Vector Vec2 3, 4, 5;
vec.insérer (VEC.end (), Vec2.begin (), Vec2.fin());
vec.efface le);
pour (auto & n: vec)
std :: cout << n << std::endl;

Tout d'abord, nous intégrons trois bibliothèques d'en-tête; L'un est #include, dans la bibliothèque de modèles standard, c'est une classe de modèle dans le langage de programmation. C'est un conteneur de séquence qui sauve des éléments. Principalement utilisé pour prendre en charge les données dynamiques dans le langage de programmation C ++. Nous pouvons étendre les vecteurs, mais cela dépend des éléments que ces vecteurs contiennent avec eux.
Le deuxième fichier d'en-tête est #include qui nous fournit de nombreuses fonctionnalités qui pourraient être à plusieurs fins, comme le trier l'élément, la prise en charge de l'algorithme de recherche, la multiplication des valeurs, le comptage des variables, etc. Enfin et surtout, c'est-à-dire que ce but est de prendre en charge notre flux d'entrée-sortie. Après les bibliothèques, nous commençons notre corps principal où nous utilisons des normes avec les vecteurs et attribuons des variables ayant un type de données entier et attribuez des valeurs à cette variable.

Voici notre déclaration où nous attribuons notre variable avec son point de départ et son point de terminaison via la fonction Maz_element. Répétez à nouveau l'instruction, mais nous passons nos valeurs en une autre variable cette fois. Ensuite, nous utilisons la fonction d'insert et passons les paramètres qui sont le point final de notre variable précédente, le point de départ de la 2ème variable et le point final de la variable. La fonction effacer () est utilisée pour effacer un seul élément du vecteur et est également utilisée pour modifier la taille du vecteur. Enfin, nous utilisons pour Loop avec la limite de notre première variable, et dans la boucle, nous affichons la variable que nous avons initialisée dans notre boucle.

Comment éviter:

Nous pouvons éviter ce type de vulnérabilité; Nous devons toujours affecter null à notre pointeur quand il devient gratuit. La plupart des gestionnaires de tas ont ignoré les pointeurs nuls libres par la suite. C'est la meilleure pratique que nous nuls tous les pointeurs supprimés ainsi que nous devons également vérifier si le pointeur est nul ou non avant de libérer le pointeur. Nous devons initialiser le pointeur null au début de notre code. Comme quand nous essayons d'utiliser la déclaration cout (std :: cout).

#inclure
Utilisation de Namespace Std;
int main()

int * i = new int ();
supprimer i;
couter<couter<<"\npointer delete successfully";
supprimer i;
couter<retour 0;

Le fichier d'en-tête est inclus. Ensuite, nous écrivons en utilisant la norme de l'espace de noms et commençons le corps du programme principal. Nous avons initialisé le pointeur avec le type de données entier. Ici, nous attribuons null au pointeur et imprimez le pointeur. Après avoir attribué le null, nous supprimons le pointeur et imprimons le message du succès. Enfin, nous vérifions à nouveau notre pointeur, et vous pouvez voir qu'il n'y a pas de pointeur existant dans notre tas de mémoire.

Conclusion:

Dans cet article, nous décrivons brièvement l'erreur double libre ou corruption. Ensuite, nous avons réaffecté notre mémoire en utilisant notre fonction () et discuté des causes de l'erreur et utilisé l'exemple de la fonction effacer (). En fin de compte, nous avons fourni une solution une solution simple et logique à cette erreur de manière très facile.