je débute en C et je me pose une question sur l'affectation.
Quand on met la valeur d'une variable locale (donc détruite à la sortie
de la fonction) dans une variable préalablement réservée dynamiquement,
celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Si oui, l'affectation est bien une copie ?
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction
fonction_appelee et une autre fois dans le tas de mon processus ?
Si oui, une fois que cette variable est affecter à sa zone mémoire
dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte
une autre valeur dans fonction_appelee ???
Bric
#include <stdio.h>
#include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */
int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée
*/
return pEntier;
/* ici la variable un_entier est détruite, ou en tous cas elle est à
considérer comme détruite car c'était une variable locale.
Idem pour la variable 'adresse de' */
}
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Stephane Zuckerman
Bonjour,
je débute en C et je me pose une question sur l'affectation. Quand on met la valeur d'une variable locale (donc détruite à la sortie de la fonction) dans une variable préalablement réservée dynamiquement, celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Oui.
Si oui, l'affectation est bien une copie ? Oui, car la variable automatique est détruite au sortir de
fonction_appelee(). De plus, les deux variables (un_entier et pEntier) ont été déclarées séparément : il ne s'agit donc pas des deux mêmes variables.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction Je ne saisis pas bien la question. Tant que vous êtes dans
fonction_appelée(), les deux variables cohabitent, et sont donc toutes les deux « allouées » ...
fonction_appelee et une autre fois dans le tas de mon processus ?
Si oui, une fois que cette variable est affecter à sa zone mémoire dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte une autre valeur dans fonction_appelee ???
Toute affectation effectuée sur une variable écrase la valeur précédemment stockée.
#include <stdio.h> #include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */ int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée */
Cette affectation ne sert à rien : on stocke l'adresse de un_entier, mais l'appel à malloc() juste derrière provoque une nouvelle affectation, écrasant la valeur précédente de pEntier (pour rappel, malloc() renvoie un pointeur vers une zone mémoire allouée par le système).
return pEntier; /* ici la variable un_entier est détruite, ou en tous cas elle est à considérer comme détruite car c'était une variable locale.
un_entier est bien détruite. Sa valeur a bien été préalablement recopiée à l'adresse pointée par pEntier (qui lui a été fournie par malloc() ).
Idem pour la variable 'adresse de' */ }
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
return 0; }
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
Bonjour,
je débute en C et je me pose une question sur l'affectation.
Quand on met la valeur d'une variable locale (donc détruite à la sortie
de la fonction) dans une variable préalablement réservée dynamiquement,
celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Oui.
Si oui, l'affectation est bien une copie ?
Oui, car la variable automatique est détruite au sortir de
fonction_appelee(). De plus, les deux variables (un_entier et pEntier) ont
été déclarées séparément : il ne s'agit donc pas des deux mêmes variables.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction
Je ne saisis pas bien la question. Tant que vous êtes dans
fonction_appelée(), les deux variables cohabitent, et sont donc toutes les
deux « allouées » ...
fonction_appelee et une autre fois dans le tas de mon processus ?
Si oui, une fois que cette variable est affecter à sa zone mémoire
dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte
une autre valeur dans fonction_appelee ???
Toute affectation effectuée sur une variable écrase la valeur précédemment
stockée.
#include <stdio.h>
#include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */
int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée
*/
Cette affectation ne sert à rien : on stocke l'adresse de un_entier, mais
l'appel à malloc() juste derrière provoque une nouvelle affectation,
écrasant la valeur précédente de pEntier (pour rappel, malloc() renvoie un
pointeur vers une zone mémoire allouée par le système).
return pEntier;
/* ici la variable un_entier est détruite, ou en tous cas elle est à
considérer comme détruite car c'était une variable locale.
un_entier est bien détruite. Sa valeur a bien été préalablement recopiée à
l'adresse pointée par pEntier (qui lui a été fournie par malloc() ).
Idem pour la variable 'adresse de' */
}
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
return 0;
}
--
"Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce
que je veux !"
"The obvious mathematical breakthrough would be development of an easy
way to factor large prime numbers." (Bill Gates, The Road Ahead)
je débute en C et je me pose une question sur l'affectation. Quand on met la valeur d'une variable locale (donc détruite à la sortie de la fonction) dans une variable préalablement réservée dynamiquement, celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Oui.
Si oui, l'affectation est bien une copie ? Oui, car la variable automatique est détruite au sortir de
fonction_appelee(). De plus, les deux variables (un_entier et pEntier) ont été déclarées séparément : il ne s'agit donc pas des deux mêmes variables.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction Je ne saisis pas bien la question. Tant que vous êtes dans
fonction_appelée(), les deux variables cohabitent, et sont donc toutes les deux « allouées » ...
fonction_appelee et une autre fois dans le tas de mon processus ?
Si oui, une fois que cette variable est affecter à sa zone mémoire dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte une autre valeur dans fonction_appelee ???
Toute affectation effectuée sur une variable écrase la valeur précédemment stockée.
#include <stdio.h> #include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */ int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée */
Cette affectation ne sert à rien : on stocke l'adresse de un_entier, mais l'appel à malloc() juste derrière provoque une nouvelle affectation, écrasant la valeur précédente de pEntier (pour rappel, malloc() renvoie un pointeur vers une zone mémoire allouée par le système).
return pEntier; /* ici la variable un_entier est détruite, ou en tous cas elle est à considérer comme détruite car c'était une variable locale.
un_entier est bien détruite. Sa valeur a bien été préalablement recopiée à l'adresse pointée par pEntier (qui lui a été fournie par malloc() ).
Idem pour la variable 'adresse de' */ }
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
return 0; }
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
Emmanuel Delahaye
In 'fr.comp.lang.c', Bric <Brac> wrote:
je débute en C et je me pose une question sur l'affectation.
Bonne question.
Quand on met la valeur d'une variable locale (donc détruite à la sortie de la fonction) dans une variable préalablement réservée dynamiquement, celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Elle existera dans la variable dynamique.
Si oui, l'affectation est bien une copie ?
Oui.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction fonction_appelee et une autre fois dans le tas de mon processus ?
Une fois en memoire automatique et une fois en mémoire allouée, oui. Le rôle d'une copie est généralement de faire une duplication. Ce n'est pas un mystère!
Si oui, une fois que cette variable est affecter à sa zone mémoire dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte une autre valeur dans fonction_appelee ???
Sauf incident, une valeur reste en mémoire tant qu'on ne la change pas. Il est évident que si on affecte la variable avec une nouvelle valeur, celle-ci change. C'est le rôle de l'affectation...
#include <stdio.h> #include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */
La variable est non seulement crée, mais initialisée. Elle contient une valeur définie.
int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée */
Ca s'appelle un pointeur. Il est crée et initialisé avec l'adresse d'une variable locale. Ok.
if((pEntier = malloc(sizeof(int))) == NULL) {
Tu crées une variable dans la zone dynamique, tu stockes son adresse dans le pointeur. (la valeur précédente du pointeur est évidemment perdue).
// traiter l'échec } else { *pEntier = un_entier;
La valeur est recopiée dans la zone dynamique. Ok.
}
return pEntier;
L'adresse de la variable dynamique est retournée. Celle-ci est parfaitement valable, y compris après l'appel de fonction, c'est à dire dans l'appelant.
/* ici la variable un_entier est détruite, ou en tous cas elle est à considérer comme détruite car c'était une variable locale. Idem pour la variable 'adresse de' */
Absolument.
}
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
Il manque la libération de l'espace alloué.
return 0; }
En tout cas, pour un débutant, je dis chapeau.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', Bric <Brac> wrote:
je débute en C et je me pose une question sur l'affectation.
Bonne question.
Quand on met la valeur d'une variable locale (donc détruite à la sortie
de la fonction) dans une variable préalablement réservée dynamiquement,
celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Elle existera dans la variable dynamique.
Si oui, l'affectation est bien une copie ?
Oui.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction
fonction_appelee et une autre fois dans le tas de mon processus ?
Une fois en memoire automatique et une fois en mémoire allouée, oui. Le rôle
d'une copie est généralement de faire une duplication. Ce n'est pas un
mystère!
Si oui, une fois que cette variable est affecter à sa zone mémoire
dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte
une autre valeur dans fonction_appelee ???
Sauf incident, une valeur reste en mémoire tant qu'on ne la change pas. Il
est évident que si on affecte la variable avec une nouvelle valeur, celle-ci
change. C'est le rôle de l'affectation...
#include <stdio.h>
#include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */
La variable est non seulement crée, mais initialisée. Elle contient une
valeur définie.
int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée
*/
Ca s'appelle un pointeur. Il est crée et initialisé avec l'adresse d'une
variable locale. Ok.
if((pEntier = malloc(sizeof(int))) == NULL) {
Tu crées une variable dans la zone dynamique, tu stockes son adresse dans le
pointeur. (la valeur précédente du pointeur est évidemment perdue).
// traiter l'échec
}
else {
*pEntier = un_entier;
La valeur est recopiée dans la zone dynamique. Ok.
}
return pEntier;
L'adresse de la variable dynamique est retournée. Celle-ci est parfaitement
valable, y compris après l'appel de fonction, c'est à dire dans l'appelant.
/* ici la variable un_entier est détruite, ou en tous cas elle est à
considérer comme détruite car c'était une variable locale.
Idem pour la variable 'adresse de' */
Absolument.
}
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
Il manque la libération de l'espace alloué.
return 0;
}
En tout cas, pour un débutant, je dis chapeau.
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
je débute en C et je me pose une question sur l'affectation.
Bonne question.
Quand on met la valeur d'une variable locale (donc détruite à la sortie de la fonction) dans une variable préalablement réservée dynamiquement, celle-ci existera toujours à la sortie de la fonction fonction_appelee ?
Elle existera dans la variable dynamique.
Si oui, l'affectation est bien une copie ?
Oui.
Elle va exister 2 fois alors ? Une fois dans la pile de la fonction fonction_appelee et une autre fois dans le tas de mon processus ?
Une fois en memoire automatique et une fois en mémoire allouée, oui. Le rôle d'une copie est généralement de faire une duplication. Ce n'est pas un mystère!
Si oui, une fois que cette variable est affecter à sa zone mémoire dynamique, elle ne bouge plus (jusqu'au free), même si je lui réaffecte une autre valeur dans fonction_appelee ???
Sauf incident, une valeur reste en mémoire tant qu'on ne la change pas. Il est évident que si on affecte la variable avec une nouvelle valeur, celle-ci change. C'est le rôle de l'affectation...
#include <stdio.h> #include <stdlib.h>
int *fonction_appelee(void) {
int un_entier = 10;/* ici, la variable un_entier est créée */
La variable est non seulement crée, mais initialisée. Elle contient une valeur définie.
int *pEntier = &un_entier; /* ici, la variable 'adresse de' est créée */
Ca s'appelle un pointeur. Il est crée et initialisé avec l'adresse d'une variable locale. Ok.
if((pEntier = malloc(sizeof(int))) == NULL) {
Tu crées une variable dans la zone dynamique, tu stockes son adresse dans le pointeur. (la valeur précédente du pointeur est évidemment perdue).
// traiter l'échec } else { *pEntier = un_entier;
La valeur est recopiée dans la zone dynamique. Ok.
}
return pEntier;
L'adresse de la variable dynamique est retournée. Celle-ci est parfaitement valable, y compris après l'appel de fonction, c'est à dire dans l'appelant.
/* ici la variable un_entier est détruite, ou en tous cas elle est à considérer comme détruite car c'était une variable locale. Idem pour la variable 'adresse de' */
Absolument.
}
int main(void) {
int *pEntier = NULL;
pEntier = fonction_appelee();
printf("Valeur de l'entier : %dn", *pEntier);
Il manque la libération de l'espace alloué.
return 0; }
En tout cas, pour un débutant, je dis chapeau.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
