Discussion :

[franc82]

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

[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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

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

Sauf quand elle est const.

[emardjean]

hum,
Quel est l'interet ?
Salutation

[Feriaman]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[emardjean]

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

[Feriaman]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
}

[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...

[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.

[Feriaman]

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.

[r0d]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Feriaman]

Ce n'est pas exact

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

3 4 5

[millie]

Ce n'est pas exact.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[Jan Rendek]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
}

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.

[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).

[Volune]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[thewho]

Bonjour,

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

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.

* 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.

[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é.

[Feriaman]

Bonjour, bonjour,

É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.

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 :

Je crois que ce que Jean Rendek voulais dire

et non pas

Je crois que ce que thewho voulais dire

.

[thewho]

Bonjour,

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

Et le cas est très différent.