Variable static dans une fonction membre

**uriotcea** · 08/07/2009, 19h15

Bonjour,

Je crée une class contenant une fonction membre dans laquelle je déclare une variable static. Maintenant si je déclare un tableau de ma class, je me demande si cette variable static est dupliquée ou si elle n'existe qu'une seul est unique fois.

Merci de vos lumiére

**jfouche** · 08/07/2009, 20h32

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
#include <iostream>
 
class Foo
{
public:
	Foo() {	}
 
	void Bar()
	{
		static int i = 0;
		std::cout << i++ << std::endl;
	}
};
 
int main(int argc, char **argv)
{
	Foo foos[10];
 
	for (size_t i = 0; i < 10; ++i) {
		foos[i].Bar();
	}
	return 0;
}

donne :
0
1
2
...

La réponse semble oui, et c'est tant mieux, c'est le but d'une variable static : garantir l'unicité de cette variable.
--
Jérémie

**Ubiquité** · 08/07/2009, 20h50

jfouche : Pourquoi size_t pour parcourir le tableau ?

**jfouche** · 08/07/2009, 20h55

Car c'est le type le plus approprié : c'est un type correspondant à une taille, ce qui est exactement ce que je veux pour parcourir un tableau. on peut aussi utiliser unsigned (short / int / long) qui représente un entier positif. Utiliser un int est moins bon car il peut être négatif, ce qui ne veux rien dire pour l'index d'un élément dans un tableau.
En somme : utiliser systématiquement le type dont la sémantique correspond à ce que je souhaite. C'est une bonne habitude à prendre que de donner des interfaces correctes.
--
Jérémie

**jfouche** · 08/07/2009, 21h12

Pour revenir à la variable locale static : On peut voir ça comme une variable membre static dont la portée est locale à la méthode où elle est déclarée.

De même qu'une variable membre static peut être vu comme une variable globale dont la visibilité est limitée à la classe où elle est déclarée. Attention, à mes yeux, les variables globales sont à limiter au maximum (entendre :à prohiber sauf cas exceptionnel).

Est ce plus clair ?
--
Jérémie

**uriotcea** · 09/07/2009, 07h57

Merci beaucoup,
C'est éffectivement trés clair et vue le comportement à visiblement utiliser avec vraiment beaucoup de procausions si ce n'est le plus rarement possible

**koala01** · 09/07/2009, 13h09

Salut,

Effectivement, une variable statique déclarée dans une fonction membre sera unique quel que soit le nombre d'instances ou le nombre d'appel de la fonction effectué.

En terme de conception, on parle d'ailleurs de membre ou de fonction "de classe" par opposition à un membre ou à une fonction "d'instance".

Le seul cas pour lequel je voies un avantage à la déclaration d'une variable statique au sein d'une fonction pourrait être la création d'une forme particulière de singleton:

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
class MySingletonClass
{
    public:
        static MySingletonClass& instance()
        {
            /* inst sera unique pour toutes les invocations de instance()
             * et sera donc créée à la première invocation de celle-ci
             */
            static MySingletonClass inst;
            return inst;
        }
        /* les fonctions (non statiques) intéressantes */
    private:
        /* le constructeur ne doit être accessible qu'au départ de
         * instance (ne pas oublier de le définir)
         */
       MySingletonClass(){}
       /* le constructeur par copie et l'opérateur d'affectation sont
        * déclarés private et ne sont pas définis (ce qui rend la classe
        * non copiable et non assignable)
        */
       MySingletonClass(MySingletonClass const &);
       MySingletonClass& operator=(MySingletonClass const & );
};

La fonction statique instance() étant appelable sans avoir recours à une instance de la classe (encore heureux, vu qu'elle permet, justement... d'obtenir une instance de la classe

), cette classe sera utilisée sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
MySingletonClass::instance().fonctionPublique1();
MySingletonClass::instance().fonctionPublique2(/*parametres éventuels */);
/* voire, si les fonctions publiques renvoient une référence sur 
 *l'instance en cours 
 */
MySingletonClass::instance().
                  fonction.publique3().
                  fonctionPublique3().
                  fonctionPublique4();

Dans tous les autres cas, il faut vraiment se poser la question de savoir s'il est intéressant que chaque invocation de la fonction partage la même variable, et la réponse est, bien souvent, non