Allocation désallocation mémoire

Bonjour à tous,
une question simple pour la majorité d'entre vous, mais qui n'est pas trop claire pour moi.

Je crée des objets en C++ avec la même variable :

Code:

---

1 2 3 4 5 6 7 8

T* varCourante; varCourante = new T(); ... varCourante = new T(); ...   varCourante = new T();

---

Est ce que quand il s'agit de la même variable, allouée plusieurs fois de suite, il faudrait d'abord desallouer pour faire une nouveau new ?
Merci pour votre aide.

Ça dépend ce que tu fais du pointeur.
Si mets chaque pointeur dans une liste, alors tu n'as pas à désallouer varCourante tant que le pointeur est dans la liste.

Si varCourante est la seule variable à contenir l'adresse de l'objet alloué, alors tu dois désallouer avant d'écraser l'adresse en question avec une autre.

Salut,

Le principe est toujours que, pour chaque new invoqué, il faut un delete correspondant avant de prendre le risque de perdre l'adresse à laquelle l'allocation a eu lieu, pour éviter le risque de fuites mémoires ("memory leaks").

Contrairement à d'autres langages (java et C#, par exemple), le C++ estime que si tu est "assez fou" pour demander une allocation dynamique, c'est que tu es en mesure de gérer toi même la libération de la mémoire en temps et en heure.

Si donc tu insère la variable qui représente ton pointeur dans un conteneur (que ce soit un vecteur, une liste, ou un conteneur associatif), tu peux envisager de n'invoquer delete que lors de la suppression de l'élément du conteneur (et au plus tard lors de la destruction du conteneur).

Si, par contre, tu ne place pas la variable qui représente ton pointeur dans un conteneur, il faut que tu libère la mémoire avant d'effectuer une nouvelle allocation dynamique de la mémoire pour le même pointeur (mais une fois que tu es sur que tu n'auras plus besoin d'accéder au pointeur).

Personnellement, plutot que de "dérouler" le code, je verrais bien plutot une boucle sous une forme proche de

Code:

---

1 2 3 4 5 6 7 8 9

T* mavar; while(test) /* aurait très bien pu être une boucle for ou un do while ;) */ { /* récupération des informations permettant de créer l'objet */ mavar = new T (/* arguments */); /* traitement avec les nouvelles valeurs */ delete mavar; }

---

Ceci dit, le C++ fournit une quantité impressionnante de possibilités d'éviter l'allocation dynamique de la mémoire, ce qui fait que, au final, il ne reste que quelques cas dans lesquels tu sois obligé d'y avoir recours.

A l'heure actuelle, il n'y a plus que trois gros cas dans lesquels on aura recours à l'allocation dynamique seront:

• Si le membre de la classe peut ne pas exister (et doit donc être créé plus tard par une méthode ad-hoc)
• Si le membre doit subsister après la destruction de l'instance dans laquelle il est créé (il faudra alors s'assurer qu'il soit effectivement détruit en temps utile)
• Si on veut mettre en œuvre le polymorphisme

Dans tous les autres cas, le recours aux différents conteneurs (pour la gestion de plusieurs éléments) ou aux références (pour éviter la copie d'une variable et/ou pour permettre aux modifications apportées à cette variable de persister après la fonction dans laquelle les modifications sont apportées) seront des alternatives réelles.

j'ai pensé utiliser une référence; mais on ne peut pas déclarer une référence comme une variable membre en C++, ce qui est le cas par exemple dans java.

Bien sûr que si -- si tu n'y arrives pas, c'est parce que tu es passé à côté des listes d'initialisation.
Mais une référence en C++ n'a rien avoir avec les références du Java

Réfléchis d'abord à pourquoi tu utilises des pointeurs. Ne peux-tu pas tout simplement mettre tes variables sur la pile d'exécution ?