Salut,
Pour la gestion de la mémoire je crois que si tu passes une primitive par valeur (une simple nombre, un simple caractère, un booléen, etc, la mémoire est libérée lorsque le programme sort du scope ou elle est utilisée.
par exemple
void use_number(int number) {
// une opération avec number...
} // <- number sort du scope ici et sa mémoire devrait être libérée
par contre si tu passes une copie d’une structure complexe comme l’instance d’un objet, à ce moment là il y aura une allocation faite sur le heap de la mémoire, et en c/c++ il me semble qu’il faut que tu libère la mémoire manuellement si ton objet est censé avoir une durée de vie limitée dans le code. C’est pour ça qu’à priori pour ce genre de structure il vaut mieux utiliser des pointeurs. Mais si tu as quand même besoin d’un copie il faut que tu utilises une fonction por nettoyer la mémoire. En c++ il me semble que tu peux libérer de la mémoire avec le mot clé delete.
struct SomeStruct {
// ... fields
};
void use_object_copy(SomeStruct an_object_copy) {
// Utiliser an_object_copy
} // <- la mémoire de an_object_copy n'est pas libérée ici
SomeStruct my_object = new SomeStruct();
SomeStruct my_object_copy = new SomeStruct();
memcpy(&my_object_copy, &my_object, sizeof(my_object_copy)); // il y a peut-être d'autres manière de faire des copies en c++ mais je ne sais plus trop..
use_object_copy(my_obect_copy);
// Ici la mémoire utilisée par my_object_copy est toujours utilisée, donc si tu sais que tu n'en auras plus besoin dans le programme tu peux libérer la mémoire avec
delete my_object_copy;
Le mot clé delete appelle le destructeur de la structure. Si ta structure contient des champs avec des allocations dynamique du genre my_object.a_field = new float(), il me semble qu’il vaut mieux implémenter ton destructeur toi même:
struct SomeStruct {
// ...
SomeStruct() { // constructor
a_number = new float();
}
SomeStruct() { // destructor
delete a_number;
}
float *a_number;
};
Voilà, mes exemples ne sont peut-être pas à recopier non plus en l’état, il doit y avoir des imprécisions, je ne fais pas beaucoup de c/c++… mais sur le principe de la gestion de la mémoire à mon avis tu peux retenir qu’il vaut mieux créer et utiliser des pointeurs pour toutes les valeurs non primitives, sinon tu dois faire la gestion de la mémoire de tes copies manuellement… Et donc pour répondre très concrètement à ta question 1: le fait que la boucle de rendu se rafraîchisse ne nettoie pas la mémoire, si tu fais une copie à chaque frame et qu’elle n’est pas nettoyée, effectivement tu auras une fuite de mémoire.
Bon courage avec ton développement !
