Il y a queque chose que je n'ai jamais compris lorsque l'on compose
deux fonctions f1 et f2 du genre
b =3D f2 ( f1 (a) );
on voit que f1 return un r=E9sultat qui devient l'argument de f2.
Or le r=E9sultat retourn=E9 par f1 occupe de la m=E9moire.
Que devient cette m=E9moire une fois l'appel de f2 termin=E9 ?
exemple :
double f1 (int a)
{
return 2.0 * a;
}
il y a bien quelquepart de la m=E9moire pour un "double" qui est
r=E9serv=E9e ?
Quand est elle lib=E9r=E9e ?
Pas forcément. Le compilo peut décider tout seul d'affecter directement le résultat à la variable qui stocke la valeur de retour.
Sinon, une implémentation 'courrante' consiste à empiler les paramètre sur une pile, et le résultat aussi. Ca doit admettre de multiples variations.
Marc Boyer --
J'ajouterai que le titre du post est donc erroné, le malloc n'intervient nullement dans ce contexte.
-- -Stan
kanze
wrote:
Il y a queque chose que je n'ai jamais compris lorsque l'on compose deux fonctions f1 et f2 du genre
b = f2 ( f1 (a) );
on voit que f1 return un résultat qui devient l'argument de f2. Or le résultat retourné par f1 occupe de la mémoire. Que devient cette mémoire une fois l'appel de f2 terminé ?
Comme a dit Marc, le problème n'est pas différent que pour le résultat de n'importe quelle expression. Et la réponse dépend des convetions de l'API -- chez moi, et les paramètres et les valeurs de retour sont dans des régistres. Sur d'autres processeurs, les paramètres se trouvent sur la pile.
exemple : double f1 (int a) { return 2.0 * a; }
il y a bien quelquepart de la mémoire pour un "double" qui est réservée ?
Il doit bien y avoir une place pour le mettre, oui. Pas forcement dans ce qu'on appelle la mémoire.
Quand est elle libérée ?
Après qu'on s'en est servi. C'est le problème du compilateur (si la valeur est en mémoire).
Le problème est un peu plus compliqué dans le cas des types de classe. Dans ce cas-là, il faut bien les mettre en mémoire (pour avoir une adresse de this), et la norme spécifie que leur destructeur sera appelé à la fin de l'expression complète. Le compilateur les met donc toujours sur la pile. (En fait, certains compilateurs sont assez intelligent pour reconnaître quand le this n'est pas réelement nécessaire, et pour mettre des petites struct dans des régistres.)
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
jeanpierre537@hotmail.com wrote:
Il y a queque chose que je n'ai jamais compris lorsque l'on
compose deux fonctions f1 et f2 du genre
b = f2 ( f1 (a) );
on voit que f1 return un résultat qui devient l'argument de
f2. Or le résultat retourné par f1 occupe de la mémoire. Que
devient cette mémoire une fois l'appel de f2 terminé ?
Comme a dit Marc, le problème n'est pas différent que pour le
résultat de n'importe quelle expression. Et la réponse dépend
des convetions de l'API -- chez moi, et les paramètres et les
valeurs de retour sont dans des régistres. Sur d'autres
processeurs, les paramètres se trouvent sur la pile.
exemple :
double f1 (int a)
{
return 2.0 * a;
}
il y a bien quelquepart de la mémoire pour un "double" qui est
réservée ?
Il doit bien y avoir une place pour le mettre, oui. Pas
forcement dans ce qu'on appelle la mémoire.
Quand est elle libérée ?
Après qu'on s'en est servi. C'est le problème du compilateur (si
la valeur est en mémoire).
Le problème est un peu plus compliqué dans le cas des types de
classe. Dans ce cas-là, il faut bien les mettre en mémoire (pour
avoir une adresse de this), et la norme spécifie que leur
destructeur sera appelé à la fin de l'expression complète. Le
compilateur les met donc toujours sur la pile. (En fait,
certains compilateurs sont assez intelligent pour reconnaître
quand le this n'est pas réelement nécessaire, et pour mettre des
petites struct dans des régistres.)
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Il y a queque chose que je n'ai jamais compris lorsque l'on compose deux fonctions f1 et f2 du genre
b = f2 ( f1 (a) );
on voit que f1 return un résultat qui devient l'argument de f2. Or le résultat retourné par f1 occupe de la mémoire. Que devient cette mémoire une fois l'appel de f2 terminé ?
Comme a dit Marc, le problème n'est pas différent que pour le résultat de n'importe quelle expression. Et la réponse dépend des convetions de l'API -- chez moi, et les paramètres et les valeurs de retour sont dans des régistres. Sur d'autres processeurs, les paramètres se trouvent sur la pile.
exemple : double f1 (int a) { return 2.0 * a; }
il y a bien quelquepart de la mémoire pour un "double" qui est réservée ?
Il doit bien y avoir une place pour le mettre, oui. Pas forcement dans ce qu'on appelle la mémoire.
Quand est elle libérée ?
Après qu'on s'en est servi. C'est le problème du compilateur (si la valeur est en mémoire).
Le problème est un peu plus compliqué dans le cas des types de classe. Dans ce cas-là, il faut bien les mettre en mémoire (pour avoir une adresse de this), et la norme spécifie que leur destructeur sera appelé à la fin de l'expression complète. Le compilateur les met donc toujours sur la pile. (En fait, certains compilateurs sont assez intelligent pour reconnaître quand le this n'est pas réelement nécessaire, et pour mettre des petites struct dans des régistres.)
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
