Bonjour,

Comment désallouer un objet crée en C++ pour libérer la mémoire?
Il y a la fonction delete mais elle ne s'applique que sur les pointeurs et ça crash quand je mets son adresse.

Exemple:
MyObject o = MyObject();
delete(&o);

Ca crashe

Que faire, vous qui savez tous programmer en C++?

PS: C'est pour un travail d'école, interdit d'utiliser du C.

Je viens de lire que ça ne sert à rien de le faire car dès qu'on sort de la fonction où il a été créé il est automatiquement libéré.

Correct?

Bien sûr que ça crache. Ton object n'a pas alloué de mémoire ici (plus exactement, il utilise de la mémoire sur la pile prévue lors de la compilation, et non de la mémoire allouée sur le tas à l'exécution).

Pour comparaison, c'est comme si en C tu faisais :

unsigned long i = 17;
free(i);

Du coup, il faut que tu nous disent ce que tu cherches à faire plus globalement, car là tu sembles être sur une fausse piste.

"Je viens de lire que ça ne sert à rien de le faire car dès qu'on sort de la fonction où il a été créé il est automatiquement libéré. "

C'est précisément ça. "delete" ne sert que pour les objets créés avec le mot clef "new" (c'est-à-dire ceux que tu as alloué toi même). Pour les autres tu n'as pas à les désallouer.

En fait je voulais faire une fonction récursive avec une variable en paramètre.

Pour faire abstraction de mon code, voilà un exemple.
On s'en fiche des tests, c'est juste un exemple clair.

void decrementerToZero(){
int i = 10;
decrement(i);

//Je n'ai plus besoin de mon i, je l'efface
delete(&i);
}

void decrement(int i){
if(i==0)
return;

decrement(i--);
}

Mais comme tu l'expliques, je n'ai pas à désallouer mon i car à la sortie de decrementerToZero il sera effacé tout seul puisqu'il est sur une pile et non une zone mémoire.
Donc j'ai compris maintenant

surtout que le i de la fonction decrementerToZero n'est pas le même que ceux de chacun des appels à la fonction decrement. Donc s'il fallait désallouer le premier il faudrait aussi désallouer chacun des autres.

En réalité c'est ce qui se passe, mais c'est géré par le compilateur (en assembleur tu aurais besoin de faire ça tout seul).

Ah ouais c'est vrai un int passé en paramètre est copié donc ça sert à rien.
Enfin c'était pour l'exemple, ce n'est pas du tout mon code.

Difficile de faire une démonstration sans la personne en face et un tableau blanc.

Il faut faire la différence entre :
- Variable allouée statiquement ou dynamiquement
- Variable allouée sur la pile ou sur le tas.

Y'a qu'en comprenant ces 2 concepts que tu pourras savoir quand il faut supprimer manuellement les objets.

Si je fais :

std::string str1("Ceci est une chaîne");
std::string* str2 = new std::string("Ceci est une chaîne");

str1 est alloué statiquement
str2 est alloué dynamiquement

str1 sera détruit en sortant de portée (retour de fonction typiquement).
Par contre str2 continuera d'exister pour toute la durée du programme à moins d'être supprimé manuellement.

Variable allouée statiquement = mémoire allouée sur la pile
Variable allouée dynamiquement = mémoire allouée sur le tas (new, malloc, ...)

Mais. Quand tu fais :

std::string* str2 = new std::string("chaine");

en fait tu définis un pointeur, str2 (qui lui est statique), lequel pointe vers une chaine de caractères, qui elle est créée dynamiquement par new().

Donc new() se charge de réserver la mémoire nécessaire, d'initialiser la chaîne en fonction de son paramètre, et renvoie une référence vers l'objet créé. C'est bien ça ?

(désolé de m'incruster dans la discussion mais ça fait un certain temps que j'essaie de comprendre ces histoires de constructeurs ^^)

Si tu fait new, tu dois desallouer avec delete.
si tu fais new[], tu dois desallouer avec delete[].

Si l'objet est construit sans allocation explicite, il est desalloue automatiquement a la fin du bloc.

example
//1
{
Foo* f = new foo();
//do stuff
delete f;
}
//2
{
Foo* f =new foo[12];
//do stuff
delete[] f;
}

//3
{
Foo f;
//do stuff
}//pas besoin de delete, l'objet est desalouer ici meme

Je précise juste qu'un objet alloué ainsi

std::string str("hello");

utilisera déjà la mémoire du tas suivant l'implémentation du compilateur. Donc c'est assez raccourci de dire que tout ce qui est alloué statiquement se trouve dans la pile.

Il y a plusieurs chose. Il est assez probable que l'objet string sera construit sur la pile. Par contre, le constructeur de cet objet va allouer de la mémoire pour stocker sa chaîne de caratère. Et cette mémoire là sera dans le tas. Mais, le pointeur vers cette chaîne est stocké dans la pile (à l'intérieur de l'objet).

Le point important c'est que pour un objet alloué statiquement, non seulement le compilateur rend la mémoire alloué dans la pile lorsque l'objet sort de la porté (ou plus tard peut-être), mais surtout AVANT ça (et normalement dès que la porté de l'objet est terminée) il appelle le destructeur de l'objet qui rend la mémoire que l'objet (et non pas le compilateur) a alloué dans le tas.