Bonjour
Comment fait-on pour qu'une même variable soit utilisable dans plusieurs
fonctions avec la même valeur et que si on change la valeur de cette
variable dans une fonction, dans la fonction suivante cette valeur ait
changé ?
En fait, c'est comme si les fonctions était toutes develloppées dans le
main afin d'avoir une continuité dans la variable.
Avec #define a 1
a ne peut pas changer de valeur dans le programme.
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
Nicolas aunai
Billiob a écrit:
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance Billiob
salut,
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
Bonjour
Comment fait-on pour qu'une même variable soit utilisable dans
plusieurs fonctions avec la même valeur et que si on change la valeur
de cette variable dans une fonction, dans la fonction suivante cette
valeur ait changé ?
En fait, c'est comme si les fonctions était toutes develloppées dans
le main afin d'avoir une continuité dans la variable.
Avec #define a 1
a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance
Billiob
salut,
plusieurs solutions a mon avis :
1) passer un pointeur sur ta variable (déclarée dans le main) a chq
fonction... chacune des fonctions modifie donc la variable..
2) passer la variable par valeur aux fonctions qui retournent la nouvelle
valeur a la fin
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je
préfère la solution 1/
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance Billiob
salut,
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance Billiob
salut,
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je sais que certains dans ce forum n'apprécient pas ce genre de pratique.
Anh Vu
Nicolas aunai wrote:
Billiob a écrit:
Bonjour
Comment fait-on pour qu'une même variable soit utilisable dans
plusieurs fonctions avec la même valeur et que si on change la valeur
de cette variable dans une fonction, dans la fonction suivante cette
valeur ait changé ?
En fait, c'est comme si les fonctions était toutes develloppées dans
le main afin d'avoir une continuité dans la variable.
Avec #define a 1
a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance
Billiob
salut,
plusieurs solutions a mon avis :
1) passer un pointeur sur ta variable (déclarée dans le main) a chq
fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la nouvelle
valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je
préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je
sais que certains dans ce forum n'apprécient pas ce genre de pratique.
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
Merci d'avance Billiob
salut,
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je sais que certains dans ce forum n'apprécient pas ce genre de pratique.
Anh Vu
Nicolas aunai
Anh Vu Tran a écrit:
salut,
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
ah bah ouais.. mais ça ct pas dit donc on c pas.... mais si c le cas, on prend la solution 1/
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je sais que certains dans ce forum n'apprécient pas ce genre de pratique.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je l'ai mis exprès ici pour voir ce qu'on allait me dire :oD
plusieurs solutions a mon avis :
1) passer un pointeur sur ta variable (déclarée dans le main) a chq
fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la
nouvelle valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
ah bah ouais.. mais ça ct pas dit donc on c pas.... mais si c le cas, on
prend la solution 1/
3) déclarer la variable en static, toutefois j'aime pas trop ça, et
je préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je
sais que certains dans ce forum n'apprécient pas ce genre de pratique.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je l'ai mis
exprès ici pour voir ce qu'on allait me dire :oD
plusieurs solutions a mon avis : 1) passer un pointeur sur ta variable (déclarée dans le main) a chq fonction... chacune des fonctions modifie donc la variable..
Oui.
2) passer la variable par valeur aux fonctions qui retournent la nouvelle valeur a la fin
C'est tordu. Et si la fonction devait aussi retourner autre chose ?
ah bah ouais.. mais ça ct pas dit donc on c pas.... mais si c le cas, on prend la solution 1/
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
La solution la plus simple : faire une variable globale, même si je sais que certains dans ce forum n'apprécient pas ce genre de pratique.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je l'ai mis exprès ici pour voir ce qu'on allait me dire :oD
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je
l'ai mis exprès ici pour voir ce qu'on allait me dire :oD
Si tu déclares ta variable en static, ok elle va être allouée sur le tas et conservera sa valeur entre les appels, mais comme tu l'as déclarée dans une fonction elle ne sera accessible qu'à cette fonction.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du bloc dans lequel elle a été déclarée (le crochet fermant corresondant suivant ou la fin du "fichier"*).
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça élimine le risque d'embrouiller les autres...
Il n'y a pas non plus de mal à utiliser des variables globales, le problème est que souvent les gens les utilisent là où ce n'est pas nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le HINSTANCE de l'application dans une variable globale.
* Oui la notion de fichier n'a pas de sens en C et on parle plutôt d'unité syntaxique ou un truc du genre...
3) déclarer la variable en static, toutefois j'aime pas trop ça, et
je préfère la solution 1/
NON.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je
l'ai mis exprès ici pour voir ce qu'on allait me dire :oD
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
et conservera sa valeur entre les appels, mais comme tu l'as déclarée
dans une fonction elle ne sera accessible qu'à cette fonction.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire
qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du
bloc dans lequel elle a été déclarée (le crochet fermant corresondant
suivant ou la fin du "fichier"*).
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça
élimine le risque d'embrouiller les autres...
Il n'y a pas non plus de mal à utiliser des variables globales, le
problème est que souvent les gens les utilisent là où ce n'est pas
nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le
HINSTANCE de l'application dans une variable globale.
3) déclarer la variable en static, toutefois j'aime pas trop ça, et je préfère la solution 1/
NON.
ah bon.. décidément, comprendrais jamais ces trucs de static :/ je
l'ai mis exprès ici pour voir ce qu'on allait me dire :oD
Si tu déclares ta variable en static, ok elle va être allouée sur le tas et conservera sa valeur entre les appels, mais comme tu l'as déclarée dans une fonction elle ne sera accessible qu'à cette fonction.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du bloc dans lequel elle a été déclarée (le crochet fermant corresondant suivant ou la fin du "fichier"*).
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça élimine le risque d'embrouiller les autres...
Il n'y a pas non plus de mal à utiliser des variables globales, le problème est que souvent les gens les utilisent là où ce n'est pas nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le HINSTANCE de l'application dans une variable globale.
* Oui la notion de fichier n'a pas de sens en C et on parle plutôt d'unité syntaxique ou un truc du genre...
Emmanuel Delahaye
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
et conservera sa valeur entre les appels, mais comme tu l'as déclarée
Oui. Elle est allouée dans la mémoire statique et initalisée avant l'exécution des fontions. Point.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
bloc dans lequel elle a été déclarée (le crochet fermant corresondant
Crochet '[]'? Non. Accolade '{}'.
suivant ou la fin du "fichier"*).
On dit 'unité de compilation' ou 'module' ('compile unit'). La portée est étendue au module uniquement si la variable est définie hors fonction.
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça élimine le risque d'embrouiller les autres...
Ahem...
Il n'y a pas non plus de mal à utiliser des variables globales, le problème est que souvent les gens les utilisent là où ce n'est pas nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le HINSTANCE de l'application dans une variable globale.
Hum... en en reparlera avec les threads... mais pas ici!
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" <cns2@cns.invalid> wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
et conservera sa valeur entre les appels, mais comme tu l'as déclarée
Oui. Elle est allouée dans la mémoire statique et initalisée avant
l'exécution des fontions. Point.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire
qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu
importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static
duration').
bloc dans lequel elle a été déclarée (le crochet fermant corresondant
Crochet '[]'? Non. Accolade '{}'.
suivant ou la fin du "fichier"*).
On dit 'unité de compilation' ou 'module' ('compile unit'). La portée est
étendue au module uniquement si la variable est définie hors fonction.
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça
élimine le risque d'embrouiller les autres...
Ahem...
Il n'y a pas non plus de mal à utiliser des variables globales, le
problème est que souvent les gens les utilisent là où ce n'est pas
nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le
HINSTANCE de l'application dans une variable globale.
Hum... en en reparlera avec les threads... mais pas ici!
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
et conservera sa valeur entre les appels, mais comme tu l'as déclarée
Oui. Elle est allouée dans la mémoire statique et initalisée avant l'exécution des fontions. Point.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
C'est ce qu'on appelle en anglais le "scope". Grossièrement ça veut dire qu'elle existe entre le moment où elle est déclarée et jusqu'à la fin du
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
bloc dans lequel elle a été déclarée (le crochet fermant corresondant
Crochet '[]'? Non. Accolade '{}'.
suivant ou la fin du "fichier"*).
On dit 'unité de compilation' ou 'module' ('compile unit'). La portée est étendue au module uniquement si la variable est définie hors fonction.
Pourquoi ne pas plutôt poser la question que de répondre au hasard ? Ça élimine le risque d'embrouiller les autres...
Ahem...
Il n'y a pas non plus de mal à utiliser des variables globales, le problème est que souvent les gens les utilisent là où ce n'est pas nécessaire. Par exemple en Win32 il n'y a aucun problème à mettre le HINSTANCE de l'application dans une variable globale.
Hum... en en reparlera avec les threads... mais pas ici!
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Bruno Desthuilliers
Billiob wrote:
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
C'est...
Trois solutions a priori: La solution "je code avec mes pieds"[1] : tu utilise une variable globale. C'est crade, parce que : - il faut faire des recherches un peu partout pour savoir d'où vient cette variable, - toutes les fonctions utilisant cette variable sont dépendantes de l'existence de cette variable -> donc tu ne peux pas utiliser ces fonctions indépendamment de cette variable. - plus il y a de fonctions qui utilisent cette variable, plus il devient difficile de savoir qui la modifie et quand -> ça devient vite un cauchemar de maintenance.
La solution "Pure Laine" : Tu passe un pointeur sur cette variable à toutes les fonctions en ayant besoin. Ca règle tous les problèmes ci-dessus, mais avec un inconvénient : il faut toujours avoir cette variable 'sous la main' pour la passer aux dites fonctions, ce qui n'est pas toujours possible.
La solution "Module" : Toutes les fonctions utilisant cette variables sont définies dans une même unité de compilation. La variable est globale *à cette unité de compilation* et masquée aux autres (mot-clé 'static' pour une variable définie *en dehors d'une fonction*). Le problème est que le code n'est pas réentrant (mais il y a des moyens d'y remédier, par exemple en ayant dans le module plusieurs instances de cette variable, chacune étant associée à un des threads appelant...)
Il y a probablement encore d'autres solutions, mais je pense qu'une des trois ferait ton affaire.
HTH, Bruno
[1] Bon, d'accord, ça dépend aussi de la taille et de l'architecture du programme, et de la réutilisabilité potentielle des fonctions... Mais c'est quand même crade, donc à éviter autant que possible.
Billiob wrote:
Bonjour
Comment fait-on pour qu'une même variable soit utilisable dans plusieurs
fonctions avec la même valeur et que si on change la valeur de cette
variable dans une fonction, dans la fonction suivante cette valeur ait
changé ?
En fait, c'est comme si les fonctions était toutes develloppées dans le
main afin d'avoir une continuité dans la variable.
Avec #define a 1
a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
C'est...
Trois solutions a priori:
La solution "je code avec mes pieds"[1] : tu utilise une variable
globale. C'est crade, parce que :
- il faut faire des recherches un peu partout pour savoir d'où vient
cette variable,
- toutes les fonctions utilisant cette variable sont dépendantes de
l'existence de cette variable -> donc tu ne peux pas utiliser ces
fonctions indépendamment de cette variable.
- plus il y a de fonctions qui utilisent cette variable, plus il devient
difficile de savoir qui la modifie et quand -> ça devient vite un
cauchemar de maintenance.
La solution "Pure Laine" :
Tu passe un pointeur sur cette variable à toutes les fonctions en ayant
besoin. Ca règle tous les problèmes ci-dessus, mais avec un inconvénient
: il faut toujours avoir cette variable 'sous la main' pour la passer
aux dites fonctions, ce qui n'est pas toujours possible.
La solution "Module" :
Toutes les fonctions utilisant cette variables sont définies dans une
même unité de compilation. La variable est globale *à cette unité de
compilation* et masquée aux autres (mot-clé 'static' pour une variable
définie *en dehors d'une fonction*). Le problème est que le code n'est
pas réentrant (mais il y a des moyens d'y remédier, par exemple en ayant
dans le module plusieurs instances de cette variable, chacune étant
associée à un des threads appelant...)
Il y a probablement encore d'autres solutions, mais je pense qu'une des
trois ferait ton affaire.
HTH,
Bruno
[1] Bon, d'accord, ça dépend aussi de la taille et de l'architecture du
programme, et de la réutilisabilité potentielle des fonctions... Mais
c'est quand même crade, donc à éviter autant que possible.
Bonjour Comment fait-on pour qu'une même variable soit utilisable dans plusieurs fonctions avec la même valeur et que si on change la valeur de cette variable dans une fonction, dans la fonction suivante cette valeur ait changé ? En fait, c'est comme si les fonctions était toutes develloppées dans le main afin d'avoir une continuité dans la variable. Avec #define a 1 a ne peut pas changer de valeur dans le programme.
J'espère que c'est assez clair.
C'est...
Trois solutions a priori: La solution "je code avec mes pieds"[1] : tu utilise une variable globale. C'est crade, parce que : - il faut faire des recherches un peu partout pour savoir d'où vient cette variable, - toutes les fonctions utilisant cette variable sont dépendantes de l'existence de cette variable -> donc tu ne peux pas utiliser ces fonctions indépendamment de cette variable. - plus il y a de fonctions qui utilisent cette variable, plus il devient difficile de savoir qui la modifie et quand -> ça devient vite un cauchemar de maintenance.
La solution "Pure Laine" : Tu passe un pointeur sur cette variable à toutes les fonctions en ayant besoin. Ca règle tous les problèmes ci-dessus, mais avec un inconvénient : il faut toujours avoir cette variable 'sous la main' pour la passer aux dites fonctions, ce qui n'est pas toujours possible.
La solution "Module" : Toutes les fonctions utilisant cette variables sont définies dans une même unité de compilation. La variable est globale *à cette unité de compilation* et masquée aux autres (mot-clé 'static' pour une variable définie *en dehors d'une fonction*). Le problème est que le code n'est pas réentrant (mais il y a des moyens d'y remédier, par exemple en ayant dans le module plusieurs instances de cette variable, chacune étant associée à un des threads appelant...)
Il y a probablement encore d'autres solutions, mais je pense qu'une des trois ferait ton affaire.
HTH, Bruno
[1] Bon, d'accord, ça dépend aussi de la taille et de l'architecture du programme, et de la réutilisabilité potentielle des fonctions... Mais c'est quand même crade, donc à éviter autant que possible.
Bruno Desthuilliers
Billiob wrote:
Merci à tous. je pense m'en sortir avec une variable globale.
*A priori*, mauvais choix :(
Bruno
Billiob wrote:
Merci à tous.
je pense m'en sortir avec une variable globale.
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
Aïe pas la tête... "heap" n'est pas non plus synonyme de mémoire dynamique.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static' ne convient pas dans le cas présent. A moins que la solution soit de déclarer la variable static dans une fonction, d'en récupérer un pointeur et de le ballader partout... beurk beurk beurk
Si tu déclares ta variable en static, ok elle va être allouée sur le
tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est
non.
Aïe pas la tête...
"heap" n'est pas non plus synonyme de mémoire dynamique.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie
(duration).
Le scope d'une variable définie dans une fonction (static ou non, peu
importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka
'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static'
ne convient pas dans le cas présent.
A moins que la solution soit de déclarer la variable static dans une
fonction, d'en récupérer un pointeur et de le ballader partout... beurk
beurk beurk
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
Aïe pas la tête... "heap" n'est pas non plus synonyme de mémoire dynamique.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static' ne convient pas dans le cas présent. A moins que la solution soit de déclarer la variable static dans une fonction, d'en récupérer un pointeur et de le ballader partout... beurk beurk beurk
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
Aïe pas la tête... "heap" n'est pas non plus synonyme de mémoire dynamique.
En tout cas, c'est hors sujet ici.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Hehe!
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static' ne convient pas dans le cas présent. A moins que la solution soit de déclarer la variable static dans une fonction, d'en récupérer un pointeur et de le ballader partout... beurk beurk beurk
Ca se fait au niveau applicatif. Pas dans une bibliothèque, bien sûr (sauf pour certaines fonctions systèmes, genre traceur de malloc()...).
Au fait les threads c'est où pas dans la norme ?
Pas dans la norme.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" <cns2@cns.invalid> wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le
tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est
non.
Aïe pas la tête...
"heap" n'est pas non plus synonyme de mémoire dynamique.
En tout cas, c'est hors sujet ici.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Hehe!
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie
(duration).
Le scope d'une variable définie dans une fonction (static ou non, peu
importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka
'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static'
ne convient pas dans le cas présent.
A moins que la solution soit de déclarer la variable static dans une
fonction, d'en récupérer un pointeur et de le ballader partout... beurk
beurk beurk
Ca se fait au niveau applicatif. Pas dans une bibliothèque, bien sûr (sauf
pour certaines fonctions systèmes, genre traceur de malloc()...).
Au fait les threads c'est où pas dans la norme ?
Pas dans la norme.
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Cyrille "cns" Szymanski" wrote:
Si tu déclares ta variable en static, ok elle va être allouée sur le tas
Non. Pas de 'tas' en C. Si tu parles de la mémoire dynamique, c'est non.
Aïe pas la tête... "heap" n'est pas non plus synonyme de mémoire dynamique.
En tout cas, c'est hors sujet ici.
dans une fonction elle ne sera accessible qu'à cette fonction.
Oui, mais rien n'empêche de retourner un pointeur sur cette variable.
Hum... On en reparlera avec les threads...
Hehe!
Non. Le scope, c'est la portée. Tu confonds avec la durée de vie (duration).
Le scope d'une variable définie dans une fonction (static ou non, peu importe) est le bloc dans lequel cette variable est définie.
La durée (l'existence) est 'static', c'est à dire permanente (aka 'static duration').
Je parlais bien de la portée car c'est à cause de la portée que 'static' ne convient pas dans le cas présent. A moins que la solution soit de déclarer la variable static dans une fonction, d'en récupérer un pointeur et de le ballader partout... beurk beurk beurk
Ca se fait au niveau applicatif. Pas dans une bibliothèque, bien sûr (sauf pour certaines fonctions systèmes, genre traceur de malloc()...).
Au fait les threads c'est où pas dans la norme ?
Pas dans la norme.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
