fonctions, tableaux et pointeurs

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:

---

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 ?

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

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 ?

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. :weird:
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, ...).

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:

---

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:

---

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.

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!

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 :)

Il n'y a qu'un seul type de mémoire mais deux méthodes d'allocation (rappel : allocation désigne l'action de réserver de l'espace en mémoire système en prévision d'un usage exclusif par le programme) : statique et dynamique. La différence étant principalement que l'allocation statique exige de connaître la taille du bloc à réserver à la compilation, contrainte absente de la seconde.

Ces deux méthodes ont leurs cibles privilégiées : la pile et le tas, respectivement. Tu trouveras ailleurs de nombreuses explications détaillées sur ce que sont l'un et l'autre, comment ils fonctionnent et quelles garanties ils offrent. Pour résumer très brièvement, ce sont deux zones distinctes en mémoire et :

• les variables locales, les paramètres de fonctions et les sauvegardes de contexte (lors de l'appel d'une fonction) sont placés sur la pile, leur allocation et leur libération sont implicites ;
• les blocs renvoyés par new ou malloc sont alloués sur le tas ; en fin d'utilisation, leur libération nécessite un appel explicite de la part de leur propriétaire (à savoir : ton programme).

Citation:

---

Envoyé par RazLaCrepe

comment delete[] sait que la longueur du tableau est 3 doubles ?

---

Le système d'exploitation, responsable de la gestion de la mémoire entre tous les processus, conserve une table des adresses de tous les blocs alloués sur le tas ainsi que leur taille. Ces informations sont récupérées et utilisées lors d'un appel à delete[] / delete / free.

Peu lui chaut d'ailleurs que tu stockes trois objets de type double au sein de ce bloc, il n'en a pas conscience. Seul lui importe le fait que la taille du bloc est 3 * sizeof(double) bytes (octets).

Citation:

---

Envoyé par RazLaCrepe

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 ?

---

C'est tout à fait cela.

Citation:

---

Envoyé par RazLaCrepe

Si c'est le cas existe-t-il une fonction qui renvoie la taille d'un tel tableau en prenant d en argument ?

---

Réponse courte : non, car le processus à l'origine de l'allocation connaît déjà - par définition - la taille du bloc qu'il demande. C'est à lui de la conserver si c'est pertinent.

Réponse plus précise : oui, parfois. C'est très dépendant du système d'exploitation et de l'implémentation de l'allocateur. Tu n'en auras jamais l'usage si tu ne fais pas de programmation système.

Note sur la taille et delete[]:
L'information de taille du tableau est stockée en interne et le standard C++ ne définit aucun moyen pour le code utilisateur de récupérer cette taille.

D'ailleurs, pour des tableaux de types "plain old data" (POD) comme double (en gros, tous les types n'ayant pas de destructeur), il est possible que cette information ne soit même pas retenue, et que seule la taille mémoire réservée (qui peut être plus grande que celle du tableau) le soit! L'implémentation peut faire ce qu'elle veut du moment que:

1. L'OS s'y retrouve quand il s'agit de libérer la mémoire,
2. Les destructeurs sont appelés quand il y en a.