J'ai un doute sur le fonctionnement des variables static et je n'arrive pas
à trouver une doc qui m'explique ça.(si quelqu'un à un lien ca m'intéresse)
J'ai le code suivant
class A {
public:
void f();
}
void A::f()
{
static bool bFirst = true;
// traitements
}
Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou
bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Pierre Lairez
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et
c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir
de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo
{
void f();
};
void foo::f ()
{
static int i = 1;
std::cout << (i++) << std::endl;
return;
}
int main()
{
foo a, b;
a.f();
a.f();
b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio <watch.the@stars.fr> a écrit:
class A {
public:
void f();
}
void A::f()
{
static bool bFirst = true;
// traitements
}
Est ce que j'ai une variable bFirst pour chacun de mes objets de
classe A ou
bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe.
persistante d'un appel à l'autre de la fonction et allouer dans la zone
statique.
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Julien Lamy
Pascal Pizeine wrote:
Bonjour,
J'ai un doute sur le fonctionnement des variables static et je n'arrive pas � trouver une doc qui m'explique �a.(si quelqu'un � un lien ca m'int�resse) J'ai le code suivant
class A { public: void f(); }
void A::f() { static bool bFirst = true;
// traitements }
Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
Une seule variable pour tous les objets, cf. par exemple "Le langage C++", paragraphe 7.1.2 Si tu en veux une par objet qui conserve sa valeur d'un appel de A::f à l'autre, il te faut une variable membre. -- Julien
Pascal Pizeine wrote:
Bonjour,
J'ai un doute sur le fonctionnement des variables static et je n'arrive pas
� trouver une doc qui m'explique �a.(si quelqu'un � un lien ca m'int�resse)
J'ai le code suivant
class A {
public:
void f();
}
void A::f()
{
static bool bFirst = true;
// traitements
}
Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou
bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
Une seule variable pour tous les objets, cf. par exemple "Le langage
C++", paragraphe 7.1.2
Si tu en veux une par objet qui conserve sa valeur d'un appel de A::f à
l'autre, il te faut une variable membre.
--
Julien
J'ai un doute sur le fonctionnement des variables static et je n'arrive pas � trouver une doc qui m'explique �a.(si quelqu'un � un lien ca m'int�resse) J'ai le code suivant
class A { public: void f(); }
void A::f() { static bool bFirst = true;
// traitements }
Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
Une seule variable pour tous les objets, cf. par exemple "Le langage C++", paragraphe 7.1.2 Si tu en veux une par objet qui conserve sa valeur d'un appel de A::f à l'autre, il te faut une variable membre. -- Julien
Pascal Pizeine
Merci pour ta réponse Pour ce qui est de mon besoin, je souhaitait utiliser cette variable statique pour différencier le premier appel de ma méthode pour chacun de mes objets. Je trouve qu'avec une variable membre c'est moins propre car elle peut être modifiée par d'autres méthodes.
Pascal
"Pierre Lairez" a écrit dans le message de news:
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Merci pour ta réponse
Pour ce qui est de mon besoin, je souhaitait utiliser cette variable
statique pour différencier le premier appel de ma méthode pour chacun de mes
objets. Je trouve qu'avec une variable membre c'est moins propre car elle
peut être modifiée par d'autres méthodes.
Pascal
"Pierre Lairez" <pierre.lairez@wanadoo.fr> a écrit dans le message de
news:opsj4pa5dru5stbh@gorille...
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et
c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir
de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo
{
void f();
};
void foo::f ()
{
static int i = 1;
std::cout << (i++) << std::endl;
return;
}
int main()
{
foo a, b;
a.f();
a.f();
b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio <watch.the@stars.fr> a écrit:
class A {
public:
void f();
}
void A::f()
{
static bool bFirst = true;
// traitements
}
Est ce que j'ai une variable bFirst pour chacun de mes objets de
classe A ou
bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe.
persistante d'un appel à l'autre de la fonction et allouer dans la zone
statique.
Merci pour ta réponse Pour ce qui est de mon besoin, je souhaitait utiliser cette variable statique pour différencier le premier appel de ma méthode pour chacun de mes objets. Je trouve qu'avec une variable membre c'est moins propre car elle peut être modifiée par d'autres méthodes.
Pascal
"Pierre Lairez" a écrit dans le message de news:
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Fabien LE LEZ
On Wed, 5 Jan 2005 13:28:43 +0100, "Pascal Pizeine" :
Pour ce qui est de mon besoin, je souhaitait utiliser cette variable statique pour différencier le premier appel de ma méthode
Avertissement habituel sur le mot méthode en C++.
pour chacun de mes objets. Je trouve qu'avec une variable membre c'est moins propre car elle peut être modifiée par d'autres méthodes.
Une méthode possible est de remplacer ta fonction par une sous-classe, qui contient la variable "bFirst" est les fonctions qui tournent autour.
Une autre méthode, que je n'ai jamais utilisée mais qui pourrait fonctionner :
if (map_not_first[this] == false) { // Premier appel map_not_first[this]= true; } else { // appels suivants } }
L'idée est de profiter du fait que les éléments d'un std::map<> sont initialisés par le constructeur par défaut (ce qui revient à la valeur "zéro" pour les types de base) lors du premier appel de operator[].
-- ;-)
On Wed, 5 Jan 2005 13:28:43 +0100, "Pascal Pizeine"
<pascal.pizeine@milesys.fr>:
Pour ce qui est de mon besoin, je souhaitait utiliser cette variable
statique pour différencier le premier appel de ma méthode
Avertissement habituel sur le mot méthode en C++.
pour chacun de mes
objets. Je trouve qu'avec une variable membre c'est moins propre car elle
peut être modifiée par d'autres méthodes.
Une méthode possible est de remplacer ta fonction par une sous-classe,
qui contient la variable "bFirst" est les fonctions qui tournent
autour.
Une autre méthode, que je n'ai jamais utilisée mais qui pourrait
fonctionner :
if (map_not_first[this] == false)
{
// Premier appel
map_not_first[this]= true;
}
else
{
// appels suivants
}
}
L'idée est de profiter du fait que les éléments d'un std::map<> sont
initialisés par le constructeur par défaut (ce qui revient à la valeur
"zéro" pour les types de base) lors du premier appel de operator[].
if (map_not_first[this] == false) { // Premier appel map_not_first[this]= true; } else { // appels suivants } }
L'idée est de profiter du fait que les éléments d'un std::map<> sont initialisés par le constructeur par défaut (ce qui revient à la valeur "zéro" pour les types de base) lors du premier appel de operator[].
-- ;-)
Fabien LE LEZ
On Wed, 05 Jan 2005 13:07:43 +0100, "Pierre Lairez" :
c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
C'est surtout qu'une fonction membre est une fonction normale, à ceci près qu'elle a un paramètre caché. Du coup,
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Je crois qu'un raisonnement permet de voir qu'effectivement chaque instance de A ne peut pas posséder sa propre instance de bFirst.
En effet, il me semble que les objets dont la classe d'allocation mémoire est statique doivent être connus à la compilation. Or, le nombre d'instances de A crées à l'exécution ne peut pas (sauf cas simples) être déterminé à la compilation, donc chaque instance de A ne peut pas posséder sa propre instance de bFirst.
Mais peut-être pourrait-on imaginer qu'un compilateur facétieux divise (à son goût.) les instances de A en deux groupes qui verraient chacun sa propre instance de bFirst. Mais je n'y crois pas beaucoup. ;-)
--
Nil
"Pierre Lairez" <pierre.lairez@wanadoo.fr> a écrit dans le message de news:
opsj4pa5dru5stbh@gorille...
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et
c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir
de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo
{
void f();
};
void foo::f ()
{
static int i = 1;
std::cout << (i++) << std::endl;
return;
}
int main()
{
foo a, b;
a.f();
a.f();
b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio <watch.the@stars.fr> a écrit:
class A {
public:
void f();
}
void A::f()
{
static bool bFirst = true;
// traitements
}
Est ce que j'ai une variable bFirst pour chacun de mes objets de
classe A ou
bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe.
persistante d'un appel à l'autre de la fonction et allouer dans la zone
statique.
Je crois qu'un raisonnement permet de voir qu'effectivement chaque instance
de A ne peut pas posséder sa propre instance de bFirst.
En effet, il me semble que les objets dont la classe d'allocation mémoire
est statique doivent être connus à la compilation. Or, le nombre d'instances
de A crées à l'exécution ne peut pas (sauf cas simples) être déterminé à la
compilation, donc chaque instance de A ne peut pas posséder sa propre
instance de bFirst.
Mais peut-être pourrait-on imaginer qu'un compilateur facétieux divise (à
son goût.) les instances de A en deux groupes qui verraient chacun sa propre
instance de bFirst. Mais je n'y crois pas beaucoup. ;-)
Personnellement, j'aurais dit pareil, mais l'expérience montre que non. Et c'est finalement assez logique: une fonction membre n'a pas besoin d'avoir de variable statique, les variables membre sont là pour ça.
#include <iostream>
struct foo { void f(); };
void foo::f () { static int i = 1; std::cout << (i++) << std::endl;
return; }
int main() {
foo a, b;
a.f(); a.f(); b.f();
}
Ce code donne bien 1, 2 puis 3.
Le Wed, 05 Jan 2005 11:51:55 +0100, fabrizio a écrit:
class A { public: void f(); } void A::f() { static bool bFirst = true; // traitements } Est ce que j'ai une variable bFirst pour chacun de mes objets de classe A ou bien n'y a t'il qu'une seule variable bFirst pour tous les objets.
à mon humble avis, une variable par instance de cette classe. persistante d'un appel à l'autre de la fonction et allouer dans la zone statique.
Je crois qu'un raisonnement permet de voir qu'effectivement chaque instance de A ne peut pas posséder sa propre instance de bFirst.
En effet, il me semble que les objets dont la classe d'allocation mémoire est statique doivent être connus à la compilation. Or, le nombre d'instances de A crées à l'exécution ne peut pas (sauf cas simples) être déterminé à la compilation, donc chaque instance de A ne peut pas posséder sa propre instance de bFirst.
Mais peut-être pourrait-on imaginer qu'un compilateur facétieux divise (à son goût.) les instances de A en deux groupes qui verraient chacun sa propre instance de bFirst. Mais je n'y crois pas beaucoup. ;-)
--
Nil
Alain Naigeon
bFirst est une variable déclarée static dans une fonction membre, ce n'est pas la même chose qu'une variable membre static. Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a pas été clairement faite ?!
--
Français *==> "Musique renaissance" <==* English midi - facsimiles - ligatures - mensuration http://anaigeon.free.fr | http://www.medieval.org/emfaq/anaigeon/ Alain Naigeon - - Strasbourg, France
bFirst est une variable déclarée static dans une fonction membre,
ce n'est pas la même chose qu'une variable membre static.
Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a
pas été clairement faite ?!
--
Français *==> "Musique renaissance" <==* English
midi - facsimiles - ligatures - mensuration
http://anaigeon.free.fr | http://www.medieval.org/emfaq/anaigeon/
Alain Naigeon - anaigeon@free.fr - Strasbourg, France
bFirst est une variable déclarée static dans une fonction membre, ce n'est pas la même chose qu'une variable membre static. Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a pas été clairement faite ?!
--
Français *==> "Musique renaissance" <==* English midi - facsimiles - ligatures - mensuration http://anaigeon.free.fr | http://www.medieval.org/emfaq/anaigeon/ Alain Naigeon - - Strasbourg, France
drkm
"Alain Naigeon" writes:
bFirst est une variable déclarée static dans une fonction membre, ce n'est pas la même chose qu'une variable membre static. Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a pas été clairement faite ?!
En effet, il semble y avoir un peu de confusion. J'ai vu plusieurs fois parler d'objets ou de classes, alors que cela n'a de rapport qu'avec la fonction elle-même (qui elle-même « n'existe qu'en un seul exemplaire »).
--drkm
"Alain Naigeon" <anaigeon@free.fr> writes:
bFirst est une variable déclarée static dans une fonction membre,
ce n'est pas la même chose qu'une variable membre static.
Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a
pas été clairement faite ?!
En effet, il semble y avoir un peu de confusion. J'ai vu plusieurs
fois parler d'objets ou de classes, alors que cela n'a de rapport
qu'avec la fonction elle-même (qui elle-même « n'existe qu'en un seul
exemplaire »).
bFirst est une variable déclarée static dans une fonction membre, ce n'est pas la même chose qu'une variable membre static. Jusqu'ici dans le fil j'ai eu l'impression que cette distinction n'a pas été clairement faite ?!
En effet, il semble y avoir un peu de confusion. J'ai vu plusieurs fois parler d'objets ou de classes, alors que cela n'a de rapport qu'avec la fonction elle-même (qui elle-même « n'existe qu'en un seul exemplaire »).
--drkm
Fabien LE LEZ
On Wed, 5 Jan 2005 18:27:59 +0100, "Alain Naigeon" :
bFirst est une variable déclarée static dans une fonction membre,
Je dirais même plus : bFirst est une variable déclarée static dans une fonction. Cette fonction se trouve être membre d'une classe, mais c'est un autre sujet.
-- ;-)
On Wed, 5 Jan 2005 18:27:59 +0100, "Alain Naigeon" <anaigeon@free.fr>:
bFirst est une variable déclarée static dans une fonction membre,
Je dirais même plus : bFirst est une variable déclarée static dans une
fonction. Cette fonction se trouve être membre d'une classe, mais
c'est un autre sujet.
On Wed, 5 Jan 2005 18:27:59 +0100, "Alain Naigeon" :
bFirst est une variable déclarée static dans une fonction membre,
Je dirais même plus : bFirst est une variable déclarée static dans une fonction. Cette fonction se trouve être membre d'une classe, mais c'est un autre sujet.
