Discussion :

[RazLaCrepe]

Bonjour,

J'ai une petite question concernant le c++, suivant la réponse il n'est pas impossible que d'autres questions s'en suivent

Supposons que je fasse la fonction suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double* maFonction(){
    double* res = new double[3];
    return(res);
}

ma fonction renvoie un pointeur sur un double... (je n'ai pas rempli les valeurs du tableau de double mais ce n'est pas important pour ma question)

ce que je ne comprends pas c'est que la variable res est déclarée localement dans la fonction, donc j'imagine que l'espace mémoire est "libéré" une fois la fonction éxécutée et peut donc être réutilisé, du coup mon pointeur pointe potentiellement sur n'importe quoi si l'espace est utilisé à nouveau non ?

[Bousk]

res est libérée à la fin de l'accolade mais pas la mémoire qu'il a alloué et sur laquelle il pointe, où pointe également le pointeur retourné (par copie) par la fonction

[RazLaCrepe]

D'accord merci. Si je fais appel a une fonction enormement de fois, il convient donc de libérer l'espace mémoire utilisé par toutes les variables et objets temporaires dans cette fonction ?

[Bousk]

Je comprends pas ce que tu racontes.

Que tu appelles ta fonction 1 ou 10000000000000 fois, ça change strictement rien aux variables allouées sur la pile, elles disparaissent avec elle (cf cours débutants : portée des variables).
Si tu fais de l'allocation dynamique, bien sur qu'il faut la libérer, sinon tu vas juste finir par crasher parce que le système n'a plus de mémoire disponible.
Btw, aujourd'hui l'appel à l'allocation dynamique peut être rare en utilisant les outils (récents) de containers de la std (vector, list, unique_ptr, ...).

[ternel]

Si on veut être plus précis, il y a une confusion entre libération de la mémoire allouée dynamiquemet (c'est à dire manuellement)

Voici un usage de ta fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
double* maFonction(){
    double* res = new double[3];
    return(res);
}
 
int main() {
    double * p = maFonction();
    delete[] p;
}

Note bien que la mémoire doit être libérée via delete[], ce qui n'est pas du tout pareil que delete.

dans l'ordre, on a:

• maFonction est appelée.
  
• new est appelée pour un double[3] pour créer un bloc mémoire (dans le tas). l'adresse du bloc créé est la valeur de cette expression.
• la valeur retournée sert à initialiser une nouvelle variable locale nommée res (de maFonction)
  
• la valeur de cette variable est utilisée pour initialiser la valeur de retour de maFonction
• on sort de la fonction: res est détruite. étant un type non-classe (ni class ni struct ni union), il n'y a pas de destructeur, donc rien n'est fait: sa valeur est juste oubliée.
  
• la valeur de retour est utilisé pour initialiser une nouvelle variable locale p (de main)
• on libère le bloc mémoire du tas désigné par l'adresse contenue dans p. (heureusement, c'est bien l'adresse d'un bloc allouée par new ... [])
  
• on sort de main
• p est détruite: même (absence de) traitement que res dans maFonction

C'est parce qu'il faut faire extrêmement attention à libérer une et une seule fois les blocs mémoires créée dans le tas que sont apparus:

• les (template de) classes de la STL comme vector, string ou map
• fstream
• les pointeurs dits intelligents dont unique_ptr et shared_ptr.

Bon, d'accord, pas uniquement pour cette raison, mais c'est un problème au cœur de ces classes.

Tu ferais probablement mieux de choisir l'une des fonctions suivantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
std::vector<double> maFonction() {
     //trois valeurs dans le vecteur, toutes égales à 0.
    return std::vector<double>(3, 0);
}
 
std::array<double, 3> maFonction() {
    return std::array<double, 3>();
}

Remarque qu'il n'y a pas besoin de parenthèses autour de la valeur retournée.

[RazLaCrepe]

Merci à vous. Oui en effet, je ne savais pas qu'il y avait deux types de mémoire (dynamique ou non) : je vais regarder ca de plus pres!

[RazLaCrepe]

Allez, une dernière question pour la route :

double* d = new double[3];

delete[] d;

comment delete[] sait que la longueur du tableau est 3 doubles ? je pensais que le pointeur était l'adresse du premier element ! Ce premier élément fait parti d'un bloc mémoire contenant tous les éléments du tableau ? Si c'est le cas existe-t-il une fonction qui renvoie la taille d'un tel tableau en prenant d en argument ?

Merci !! Je devrais réussir à m'en tirer pour la suite