Double gratuit ou de corruption après la file d'attente::push

Parlons de la copie d'objets en C++.

Test t;, appelle le constructeur par défaut, qui alloue un tableau d'entiers. Ce qui est bien, et votre comportement attendu.

Problème arrive lorsque vous appuyez t dans votre file d'attente à l'aide de q.push(t). Si vous êtes familier avec Java, C#, ou presque tout autre langage orienté objet, vous pouvez vous attendre l'objet que vous avez créé correspondante à être ajouté à la file d'attente, mais le C++ ne fonctionne pas de cette façon.

Lorsque nous prenons un coup d'oeil à std::queue::push méthode, nous voyons que l'élément qui est ajouté à la file d'attente est "initialisé à une copie de x". C'est en fait une marque nouvel objet qui utilise le constructeur de copie dupliquer chaque membre de votre original Test un objet pour faire un nouveau Test.

Votre compilateur C++ génère un constructeur de copie par défaut! C'est assez pratique, mais les causes des problèmes avec le pointeur membres. Dans votre exemple, rappelez-vous que int *myArray est une adresse de mémoire; lorsque la valeur de myArray est copié à partir de l'ancien objet de la nouvelle, vous aurez maintenant deux objets pointant vers le même tableau dans la mémoire. Ce n'est pas intrinsèquement mauvais, mais le destructeur va alors essayer de supprimer le même tableau à deux reprises, d'où le "double gratuit ou de corruption" erreur d'exécution.

Comment puis-je résoudre ce problème?

La première étape est de mettre en œuvre un constructeur de copie, qui peut en toute sécurité de copier les données d'un objet à un autre. Pour des raisons de simplicité, il pourrait ressembler à quelque chose comme ceci:

Test(const Test& other){
    myArray = new int[10];
    memcpy( myArray, other.myArray, 10 );
}

Maintenant, quand vous copiez des objets d'Essai, un nouveau tableau sera alloué pour le nouvel objet, et les valeurs de la matrice seront copiés.

Nous ne sommes pas complètement hors de la difficulté encore, cependant. Il y a une autre méthode que le compilateur génère pour vous qui pourrait conduire à des problèmes similaires de cession. La différence est que, avec affectation, nous avons déjà un objet existant, dont la mémoire a besoin d'être gérés de façon appropriée. Voici une base d'affectation opérateur de mise en œuvre:

Test& operator= (const Test& other){
    if (this != &other) {
        memcpy( myArray, other.myArray, 10 );
    }
    return *this;
}

L'important est ici que nous allons copier les données dans le tableau dans cet objet du tableau, en gardant chaque objet du mémoire distinct. Nous avons également une vérification pour l'auto-affectation; autrement, nous serions copie de nous-mêmes à nous-mêmes, ce qui peut générer une erreur (pas sûr de ce qu'il est censé le faire). Si nous étions suppression et d'allouer plus de mémoire, l'auto-attribution de vérifier nous empêche de le supprimer de la mémoire à partir de laquelle nous avons besoin de la copie.

Vous obtenez double gratuit ou la corruption parce que d'abord le destructeur est pour l'objet q dans ce cas, la mémoire allouée par nouveau sera gratuit.La prochaine fois, quand detructor sera appelé pour objet t à cette époque, la mémoire est déjà libre (fait pour q) et donc lorsque dans le destructeur delete[] montableau; exécutera qu'il va jeter double gratuit ou la corruption.
La raison en est que, à la fois objet de partage la même mémoire afin de définir \copie, de cession et de l'égalité de l'opérateur comme mentionné dans la réponse ci-dessus.

Vous pouvez également essayer de vérifier null avant de le supprimer, tels que

if(myArray) { delete[] myArray; myArray = NULL; }

ou vous pouvez définir toutes les opérations de suppression de l'ina manière sûre comme ceci:

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p) { delete (p); (p) = NULL; } }
#endif

#ifndef SAFE_DELETE_ARRAY
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p) = NULL; } }
#endif

et ensuite utiliser

SAFE_DELETE_ARRAY(myArray);