Problème de fuites mémoire

Bonjour,

Comme je suis encore débutant en programmation... J'ai des fuites. Alors j'ai une question, je vous montre le code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<typename TYPE> void Array<TYPE>::Reverse(TYPE* Sequence, int TailleSequence) { TYPE SeqAlt[TailleSequence];   for (int i=0 ; i < TailleSequence ; i++) { SeqAlt[i] = Sequence[TailleSequence-1-i]; } delete[] Sequence; Sequence = SeqAlt; }

---

Le but du jeu ici est de changer l'ordre du tableau. Pour ce faire, je crée un nouveau tableau de la même taille, nommé SeqAlt, puis j'affecte les valeurs de Sequence à SeqAlt.

Jusque là rien de bien méchant on dirait. Mais problème, valgrind me dit qu'il y a une fuite de mémoire ; normal, le tableau Sequence n'est pas libéré... Donc, je mets un "delete[] Sequence" avant de faire la nouvelle affectation.

Où est le problème, selon vous ?
(Alors, 1. non, je ne voulais pas utiliser les std::vector, et 2. je voulais que SeqAlt ne soit pas en retour de la fonction mais bien passé en adresse)

Le compilateur ne dit rien, mais à l'éxecution ça râle beaucoup...
Sans le delete[], ça ne bug plus, mais il y a me semble-t-il des fuites de mémoire...

Pourquoi ne pas faire :

Code:

---

1 2 3 4 5 6

template<typename TYPE> void Array<TYPE>::Reverse(TYPE* Sequence, int TailleSequence) { for (int a=0,b=TailleSequence-1 ; a < TailleSequence ; a++,b--) Sequence[a]= Sequence[b]; }

---

De plus faire un delete dans ta fonction Reverse n'est sémentiquement pas correct. Cette fonction a pour but d'inverser les elements d'un tableau, point.
Donc eviter de suprimer un emplacement mémoire passé en argument. C'est typiquement un example d'un type de programmation a éviter autant que faire ce peu.

OOps :oops: au temps pour moi.
Cela dit remarques interessantes.

@loufoque :

- Pour le TYPE SeqAlt[TailleTableau], en effet je suis d'accord avec toi : en fait dans la fureur d'essayer de trouver une solution j'ai écrit ça :'(
Au départ, j'avais bien écrit
TYPE * SeqAlt;
SeqAlt = new TYPE[TailleTableau];

Voilà pourquoi j'utilisais delete[].

- En quoi ma fonction n'a absolument aucun effet ? Ce que je veux faire, c'est inverser des indices ^^
- Array est juste un template qui ne contient que quelques fonctions static.
- Pour les swaps... je regarde.

Enfin merci.

Citation:

---

Envoyé par Le Barde

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<typename TYPE> void Array<TYPE>::Reverse(TYPE* Sequence, int TailleSequence) { TYPE SeqAlt[TailleSequence];   for (int i=0 ; i < TailleSequence ; i++) { SeqAlt[i] = Sequence[TailleSequence-1-i]; } delete[] Sequence; Sequence = SeqAlt; }

---

---

Principale erreur :

Tu change Sequence, mais mal ^^
Sequence = SeqAlt;
Ceçi ne fait que changer l'adresse du pointeur Sequence. Mais tu en a une copie, donc ta variable Sequence passée a ta fonction ne sera pas changée.

Solution Simple :

Code:

---

Reverse(TYPE * & Sequence, int TailleSequence)

---

En utilisant un vector, tu peux aussi utiliser reverse pour ce même effet.

Code:

---

1 2	std::vector <int> vector; // On dit que tu ajoutes 1, 2, 3, 4, 5, 6 dedans... std::reverse (vector.begin(), vector.end()) // Tu auras 6, 5, 4, 3, 2, 1.

---

Si tu tiens vraiment à créer un autre tableau, avec reverse_copy ça sera idéal :

Code:

---

1 2 3

std::vector <int> vector; // On dit que tu ajoutes 1, 2, 3, 4, 5, 6 dedans... std::vector <int> vector2 (vector.size()); // Il faut que le second vecteur ait la // même taille que le premier std::reverse_copy vector.begin(), vector.end(), vector2.begin()) // Tu auras 6, 5, 4, 3, 2, 1 dans le vector2, vector restera inchangé

---

Ah ouiiii, c'était donc ça ;)

Merci beaucoup, c'est exactement ce que je voulais faire.

Vu Bakura, nos posts se sont croisés ;)
Je vais peut-être en passer par les vector pour plus tard, mais au départ je préférais ne pas en passer par là ;)

Je parlais de vector, mais tu peux très bien utiliser un simple tableau :

Code:

---

1 2	int monTableau[] = {1, 2, 3, 4, 5}; std::reverse (monTableau, monTableau + 5);

---

Et avec reverse_copy :

Code:

---

1 2 3

int monTableau[] = {1, 2, 3, 4, 5}; int monTableau2[5]; // Nombre d'éléments du tableau 1 std::reverse_copy (monTableau, monTableau + 5, monTableau2);

---

Beaucoup d'algorithmes de la STL peuvent être utilisés sans pour autant utiliser des vector, des list ou des deque. C'est juste que c'est un peu moins pratique.

En prenant Sequence par référence, tu vas donc faire pointer ton pointeur Sequence (externe à la fonction) à un tableau qui est une variable locale de ta fonction. Variable locale qui n'existe plus.

Citation:

---

- Array est juste un template qui ne contient que quelques fonctions static.

---

Erreur de conception, donc.
Tes fonctions ne devraient pas être des fonctions membres statique d'une classe template Array, mais tout simplement des fonctions libres templates, tout comme std::reverse.

Merci beaucoup, ça fonctionne mieux ;)

:resolu: :question:

Si oui, pense à cliquer sur le bouton ad-hoc ;)

Oh, je manque à tous mes devoirs, aujourd'hui. :oops:

[RÉSOLU].