malloc( ): corruption de la mémoire (rapide) erreur C++

Je travaille en C++. Je suis en train de travailler sur une méthode pour modifier la capacité maximale d'une pile et je suis confus au sujet d'une erreur que j'obtiens. Ci-dessous est ma méthode.

void Stack::setCapacity(unsigned newCapacity){
if(newCapacity< this->getSize()){
    throw StackException("setCapacity()", 
    "the size is larger than the desired capacity");
} else {
    if(newCapacity != myCapacity){
        Item * tempArray = new Item[newCapacity];
        if(newCapacity < myCapacity){
            for(unsigned i=0; i<newCapacity;i++){
                tempArray[i] = myArray[i];
            }
        } else if (newCapacity > myCapacity) {
            for(unsigned i=0; i<myCapacity; i++){
                tempArray[i] = myArray[i];
            }
        }
        for(unsigned i=0; i<newCapacity; i++){
            myArray[i] = tempArray[i];
        }
        delete tempArray;
    }
    myCapacity = newCapacity;
} 
}

J'ai également écrit une méthode de test pour vérifier que mon setCapacity( ) la méthode fonctionne.

void StackTester::setCapacityTest() {
cout << "- setCapacity... " << flush;
//empty stack
Stack st7(5);
assert(st7.getSize() == 0);
assert(st7.getCapacity() == 5);
st7.setCapacity(7);
assert(st7.getCapacity() == 7);
cout << " 1 " << flush;
//partially filled stack - larger capacity
Stack st8(5);
assert(st8.getCapacity() == 5);
st8.push(3);
st8.push(4);
st8.setCapacity(7);
assert(st8.getCapacity() == 7);
assert(st8.getTop() == 4);
st8.pop();
assert(st8.getTop() == 3);
cout << " 2 " << flush;
//size larger than new capacity
try{
Stack st9(3);
st9.push(7);
st9.push(4);
st9.push(11);
assert(st9.getSize() == 3);
st9.setCapacity(2);
cerr << "setCapacity's new capacity is larger than the size";
exit(1);
} catch(StackException& se){
cout << " 3 " << flush;
}
//partially filled stack - smaller capacity
Stack st10(5);
assert(st10.getCapacity() == 5);
st10.push(1);
st10.setCapacity(2);
assert(st10.getCapacity() == 2);
assert(st10.getTop() == 1);
cout << " 4 " << flush;
//fully filled stack - larger capacity
Stack st11(2);
assert(st11.getCapacity() == 2);
st11.push(3);
st11.push(7);
assert(st11.getTop() == 7);
st11.setCapacity(3);
assert(st11.getCapacity() == 3);
cout << " 5 " << flush;
cout << " Passed!" << endl;
}

Quand je lance chaque section du test individuellement en commentant le reste, tout fonctionne bien. Chaque section du test passe. Cependant, quand je combine les sections et essayez d'exécuter l'ensemble du test, j'obtiens l'erreur suivante:

* glibc détecté ** * /home/.../StackProject: malloc(): corruption de la mémoire (rapide): 0x0000000001e86030 *

De l'utilisation du débogueur, j'ai réduit le problème à la création de myArray dans la Pile. Par exemple, après avoir exécuté avec succès " 1 "dans mon test, la création de myArray dans st8(5) en" 2 ", le programme crash.

Ma principale source de confusion est due au fait que chaque section passe individuellement, mais ils ne passent pas collectivement. Je ne sais pas quoi faire à ce sujet. Est ma méthode écrite de mal? Si oui, comment doit-je la corriger?

Merci.

ce que le diable se passe dans setCapacity? Vous pouvez poster votre classe deifnition pour la Pile?
Pourquoi est-malloc dans le titre et pas dans le code. Ce qui s'est passé à la deuxième extrait de code wrt indentation
Stack::setCapacity ne fait rien
pas vrai! Il ya des fuites de mémoire. C'est quelque chose.
accordée et des pertes de temps
Vous devez expliquer pourquoi vous créer tempArray. Qu'est-ce exactement les changements dans votre programme après vous delete (ce qui devrait être delete[] comme indiqué dans une réponse)?
setCapacity les changements de la taille maximale autorisée dans une pile sans provoquer un débordement de pile. Mon constructeur pour la Pile est comme suit: Stack::Stack(unsigned size) { if(!(size>0)){ throw StackException("Stack()", "invalid parameter"); } else { myTop = 0; myCapacity = size; myArray = new Item[size]; } } j'ai créé tempArray parce que j'avais besoin de créer un nouveau tableau pour mettre mes éléments. montableau a la capacité d'origine alors que tempArray a la nouvelle capacité.
créer le tableau. remplir une d de le jeter(?) loin

InformationsquelleAutor TheFaceOfBoe | 2014-10-26

c++capacity glibc malloc stack

Je vois les problèmes suivants dans setCapacity, dans le bloc de code suivant:

  if(newCapacity != myCapacity){
Item * tempArray = new Item[newCapacity];
if(newCapacity < myCapacity){
for(unsigned i=0; i<newCapacity;i++){
tempArray[i] = myArray[i];
}
} else if (newCapacity > myCapacity) {
for(unsigned i=0; i<myCapacity; i++){
tempArray[i] = myArray[i];
}
}
//When newCapacity > myCapacity, myArray does not
//have enough space for this loop.
//Say myCapacity = 5 and newCapacity = 7
//Accessing myArray[5] and myArray[6] is a problem.
for(unsigned i=0; i<newCapacity; i++){
myArray[i] = tempArray[i];
}
//You are deleting the newly allocated array, even though you are using
//the wrong delete operator.
//myArray still points to the old allocated memory.
delete tempArray;
}

Ce que vous avez besoin est:

  if(newCapacity != myCapacity){
Item * tempArray = new Item[newCapacity];
if(newCapacity < myCapacity){
for(unsigned i=0; i<newCapacity;i++){
tempArray[i] = myArray[i];
}
} else if (newCapacity > myCapacity) {
for(unsigned i=0; i<myCapacity; i++){
tempArray[i] = myArray[i];
}
}
//Need to delete the old array and keep the new array.
Item* oldArray = myArray;
myArray = tempArray;
//Use the array delete operator, not the simple delete operator.
delete [] oldArray;
}

Merci!!!! Qui a résolu le problème à la perfection.
Vous êtes les bienvenus. Heureux que j'ai été capable de les aider.

InformationsquelleAutor R Sahu

5

Vous avez
```
delete tempArray;
```
Mais c'est un tableau, de sorte que vous avez à faire:
```
delete [] tempArray;
```
(bien que je n'ai aucune idée de ce que cette fonction est en train de faire ou pourquoi... )

InformationsquelleAutor Barry

Vous devez vous connecter pour publier un commentaire.