definition d'une constante static

Version imprimable

12/12/2006, 16h11
franc82

definition d'une constante static

je voudrais savoir la syntaxe pour definir une constante static de type unsigned char dans une fonction. je le fais parce que je ne veux pas utiliser de variable globale
12/12/2006, 16h25
emardjean

Hum,
me semble un peu paradoxal...
Une constante ne peut pas etre modife et ce trouve en ROM.
Une static est une variable modifiable et ce trouve en RAM.
Je pense que tu dois te tromper quelque part...
Salutations
12/12/2006, 16h34
Feriaman
C'est exactement comme quand tu le dis, il faut préciser :
- que son type est unsigned char
- qu'elle est constante
- qu'elle est statique

Tu peux faire comme ceci :
Code:

1 2 3 4 5 void mamethode() { const static unsigned char uc = 7; }
Note : il te faut l'initialiser dans la foulée, car elle est constante (et que tu ne pourras donc pas le faire plus tard)

Citation:

Envoyé par emardjean

Une static est une variable modifiable et ce trouve en RAM.

Sauf quand elle est const.
12/12/2006, 16h37
emardjean

hum,
Quel est l'interet ?
Salutation

un des intérêts c'est que dans le code :

Code:

1
2
3
4
5
6
7
8
9
10
void mamethode()
{
	const static unsigned char uc = 7;
 
	fait_quelque_chose_avec_ceci(uc);
	fait_autre_chose_avec_ceci(uc);
	va_ceuillir_des_noisettes(uc);
	range_tes_oreilles(uc);
	ne_touche_pas_au_chocolat(uc);
}

On génère le même exécutable que dans

Code:

1
2
3
4
5
6
7
8
void mamethode()
{
	fait_quelque_chose_avec_ceci(7);
	fait_autre_chose_avec_ceci(7);
	va_ceuillir_des_noisettes(7);
	range_tes_oreilles(7);
	ne_touche_pas_au_chocolat(7);
}

Mais cela se modifie plus facilement.

Bonne journée.

12/12/2006, 16h45
emardjean

Ok,
En C++, on remplace les #define par des const static,
désolé pour mes remarques désagreables
:oops:

Citation:

Envoyé par emardjean

Ok,
En C++, on remplace les #define par des const static,
désolé pour mes remarques désagreables
:oops:

Tu peux aussi utiliser les #define, la plupart du temps le résultat est similaire.

Cependant, le #define n'est pas typé, donc le comportement peut être distinct dans ce cas-là par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 #define i2 4; void m1(unsigned int i) // cette méthode prend un unsigned int { ... } void m2() { const static int i1 = 4; m1(i1); // ceci déclenche un warning de compatibilité m1(i2); // ceci non }

12/12/2006, 16h52
Jan Rendek

Je mettrais un bémol, néanmoins. Définir la constante comme static n'apporte rien dans l'exemple.
L'interêt d'une variable de fonction déclarée 'static' est que cela permet de préserver sa valeur entre les appels successifs de la fonction.
Si cette dernière est constante, conserver sa valeur est sans objet.

Bien sûr 'static' n'a pas le même sens lors d'une déclaration de variable en dehors d'une fonction.

Pour ce qui est d'écrire la valeur des constantes dans la ROM. J'espère que c'est un abus de langage...
12/12/2006, 16h54
thewho

Bonjour,

Nul ne doute de l'intérêt de déclarer des constantes plutôt que de coder des valeurs en clair, comme tu l'as bien noté.

Par contre, j'aimerais savoir pourquoi tu tiens à ce qu'elle soit static : ça n'amène absolument rien de plus à son utilisation.

Et globalement, constante ou variable, le tout est en RAM. Qui vous a mis en tête qu'une constante était en ROM ?
Désolé, mais ce sigle fait référence à un type de mémoire physique, pas au fait qu'un élément d'un programme n'est pas modifiable.
De plus, pour certains compilateurs (tous ?), une constante n'est même pas en mémoire à un endroit précis, elle est codée en dur dans l'exécutable.
12/12/2006, 16h56
Feriaman

Citation:

Envoyé par thewho

Bonjour,
Nul ne doute de l'intérêt de déclarer des constantes plutôt que de coder des valeurs en clair, comme tu l'as bien noté.
Par contre, j'aimerais savoir pourquoi tu tiens à ce qu'elle soit static : ça n'amène absolument rien de plus à son utilisation.

Effectivement, je ne voie pas de différence induite par le fait qu'elle soit statique ... Dans tous les cas, elle est en dur dans le programme et non pas en mémoire.

Après, d'un point de vue philosophique, peut-être est-ce que le "static" insiste sur le fait qu'il s'agit de la même constante pour toutes les méthodes... ce qui pourrait être utile par exemple si quelqu'un décide un jour de modifier le code et de la rendre non-statique.
12/12/2006, 17h46
r0d
Citation:

Envoyé par Jan Rendek

L'interêt d'une variable de fonction déclarée 'static' est que cela permet de préserver sa valeur entre les appels successifs de la fonction.
Si cette dernière est constante, conserver sa valeur est sans objet.

Ce n'est pas exact. Testez le code suivant et vérifiez la valeur de i à chaque étape pour vous en convaincre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void toto(int i) { i=3; } int _tmain(int argc, _TCHAR* argv[]) { int i = 4; toto(i); return 0; }
* Ici, la valeur de i restera à 4 aprés l'appel de toto(i); donc rien à voir avec static.
* Pas besoin de définir i comme constante pour que la valeur ne soit pas modifiée (tant qu'elle reste dans sa portée).

En fait, le mot clé static ne doit pas être utilisé dans ce sens en c++. Il sert à définir des variables membres communes à toutes les instances d'une classe, et permet de faire des choses du style: int UnInt = UneClasse::UneValeur; sans avoir à instancier UneClasse.
12/12/2006, 17h57
Feriaman
Citation:

Envoyé par r0d

Ce n'est pas exact

Je crois que ce que thewho voulait dire c'est que le code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void toto() { static int i=3; std::cout << i++ << " "; } int _tmain(int argc, _TCHAR* argv[]) { toto(); toto(); toto(); return 0; }
Produit la sortie suivante :

Citation:

3 4 5

Citation:

Envoyé par r0d

Ce n'est pas exact.

Je pense que Rendek parlait d'un code comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int generer() { static int i = 0; return i++; } int main(void) { int i; int j; i = generer(); j = generer(); return 0; }

Il n'y a pas de définition de variable de fonction 'static' dans l'exemple.
Voila un exemple de mise en oeuvre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> using namespace std; void f() { static int count=0; ++count; cout << "Nb d'appels de la fct: " << count << endl; } int main() { for (int i=0; i < 10; ++i) f(); }
Citation:

En fait, le mot clé static ne doit pas être utilisé dans ce sens en c++. Il sert à définir des variables membres communes à toutes les instances d'une classe, et permet de faire des choses du style: int UnInt = UneClasse::UneValeur; sans avoir à instancier UneClasse

C'est une des utilisations du mot-clefs 'static', mais sûrement pas la seule. Personnellement j'en vois 4, et peut-être j'en ignore d'autres.

12/12/2006, 17h58
Médinoc

Ouah, un triple-cross!

Il me semble que la remarque de r0d concerne les static const ... dans une fonction. Il est raisonnable de penser que du moment que la "variable" est const, le fait qu'elle soit static ou non importe peu (du moins, dans le cas d'un type primitif. Pour un objet avec constructeur, la différence est notable).

Citation:

Envoyé par Médinoc

Il est raisonnable de penser que du moment que la "variable" est const, le fait qu'elle soit static ou non importe peu (du moins, dans le cas d'un type primitif. Pour un objet avec constructeur, la différence est notable).

Même si des cas présentant cette situation (surtout avec des types primitifs) sont probablement extrèmement rares, le programme suivant semble dire le contraire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 #include <iostream> void print(int const * ptr) { std::cout << static_cast<void const *>(ptr) << std::endl; } void foo(bool repeat) { static const int i = 2; print(&i); if (repeat) foo(false); } void bar(bool repeat) { const int i = 3; print(&i); if (repeat) bar(false); } int main(void) { foo(true); bar(true); }
Compilé avec mingw/g++(3.4.5), donne le résultat suivant :
Code:

1 2 3 4 5 6 $ g++ un_test.cpp -o un_test -Wall -ansi -pedantic -O3 $ ./un_test 0x43e000 0x43e000 0x22ff74 0x22ff40

12/12/2006, 20h15
thewho

Bonjour,

Citation:

Envoyé par Feriaman

Effectivement, je ne voie pas de différence induite par le fait qu'elle soit statique ... Dans tous les cas, elle est en dur dans le programme et non pas en mémoire.

Après, d'un point de vue philosophique, peut-être est-ce que le "static" insiste sur le fait qu'il s'agit de la même constante pour toutes les méthodes... ce qui pourrait être utile par exemple si quelqu'un décide un jour de modifier le code et de la rendre non-statique.

Étant définie dans une fonction, sa portée est limitée à cette fonction

Citation:

Envoyé par Feriaman

e crois que ce que thewho voulait dire c'est que le code

J'aimerais bien connaître la suite de réflexions qui te conduit à ça par rapport à ce que j'ai écrit.

Citation:

Envoyé par r0d

* Ici, la valeur de i restera à 4 aprés l'appel de toto(i); donc rien à voir avec static.
* Pas besoin de définir i comme constante pour que la valeur ne soit pas modifiée (tant qu'elle reste dans sa portée).

Encore heureux, tu la passes par valeur à une fonction, qui travaille donc sur une copie locale.
Mais passe-la par erreur à une fonction qui va la prendre en référence, et tu verras, alors que définie comme const, tu auras au minimum ton compilateur qui va te rappeler à l'ordre.
12/12/2006, 20h17
Jan Rendek

Il ne faut pas tout confondre. Un compilateur, d'abord il compile et ensuite il optimise. Pour toute variable, il alloue un espace mémoire pour y stocker sa valeur.
Dans la passe d'optimisation, s'il détecte qu'on utilise jamais l'adresse d'une variable constante (et quelques autres tests) alors il peut choisir d'uniquement copier la valeur de cette constante. En d'autre terme UNIQUEMENT si les conditions sont réunies, une variable scalaire constante sera remplacée par sa valeur 'immédiate'.

A partir du moment ou dans ton code tu demandes explicitement l'adresse de la variable, le compilateur sera forcé de lui allouer un espace mémoire. En bref, ton test ne prouve rien.
Si tu veux voir cette optimisation à l'oeuvre, il te faudra écrire un bout de code qui l'autorise et regarder l'assembleur généré.
13/12/2006, 09h41
Feriaman

Bonjour, bonjour,

Citation:

Envoyé par thewho

Étant définie dans une fonction, sa portée est limitée à cette fonction

Je l'entend bien, mais je ne voie pas ce que cela vient faire ici.
La portée d'une variable de méthode statique est bien cette méthode et uniquement cette méthode, mais il n'existe qu'une seule variable statique pour tous les appels de cette méthode, et elle garde sa valeur d'un appel sur l'autre.

Pour éclairer le point que tu cite, je disais donc que si cela ne change rien de déclarer statique une variable constante d'un type primitif, cela peut éclairer sur les intentions de l'auteur du code.
Imaginons un jeu en mode console, où chaque objet de jeu connait le symbole qui le représente à l'écran. On peut vouloir utiliser une variable "static const char" pour le symbole en question. Non pas que cela change grand chose par rapport à un "const char", mais si un jour on rend le programme paramétrable de sorte que l'utilisateur puisse choisir les symboles des objets, ces variables ne seront plus "const", mais toujours "static".
Enfin, ceci est une considération plus psychologique ou philosophique que génie logiciel, je l'accorde volontiers.

Citation:

Envoyé par thewho

J'aimerais bien connaître la suite de réflexions qui te conduit à ça par rapport à ce que j'ai écrit.

Toutes mes excuses, je me suis trompé de citation. Il fallait donc lire :

Citation:

Je crois que ce que Jean Rendek voulais dire

et non pas

Citation:

Je crois que ce que thewho voulais dire

.
13/12/2006, 11h41
thewho

Bonjour,

Arrêtez de nous parler de variable, il s'agit d'une constante.

Et le cas est très différent.