Accéder à des instances statiques de classe

[mulfycrowh]

Bonjour,

J'ai créé statiquement trois instances d'une classe Z : A B et C dans un fichier cpp.
Comment accéder à ces trois instances à partir d'un autre cpp ?

Merci

[moldavi]

Bonjour.

Je te donne du code (fait sous Visual Studio) :

main.cpp :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
#include "extern.h"
#include "test.h"
 
void main(){
 
		A.Faire();
		B.Faire();
		C.Faire();
 
		Test t;
		t.FaireLeTest();
}

extern.h :

Code :

1
2
3
4
5
#include "class.h"
 
static Z A;
static Z B;
static Z	C;

class.h :

Code :

1
2
3
4
5
6
7
8
9
#include <Windows.h>
 
class Z{
 
public:
 
		void Faire(){ MessageBox(NULL, L"Je fais", L"", MB_OK); }
 
};

test.h

Code :

1
2
3
4
5
6
7
class Test{
 
public:
 
		void FaireLeTest();
 
};

test.cpp

Code :

1
2
3
4
5
6
7
8
9
#include "test.h"
#include "extern.h"
 
void Test::FaireLeTest(){
 
		A.Faire();
		B.Faire();
		C.Faire();
}

Avec ceci, les classes A, B et C sont utilisées dans main.cpp et test.cpp.

J'ai déclaré les variables statiques dans un .h. Si je ne dis pas de bêtises, une variable déclarée statique dans un .cpp ne pourra être connue que dans ce même .cpp.

[Bousk]

Bonjour,

Je pense qu'il y a mecomprehension du langage et des mots-clés.
Que veux-tu faire réellement ?
Sais-tu vraiment comment s'utilise static ?

[Awakening]

Bonjour,

Pourrais tu préciser ce que tu voudrais faire ?

Il est possible que cet exemple t'aide :

Code :

1
2
3
4
5
6
7
8
9
//fichier z.h
class Z
{
    Z(int id) : mId(id) {}
private:
    int id() const { return mId;}
public:
    static Z A, B, C; // variables a initialiser dans un fichier .cpp (par exemple z.cpp)
};

Tu peux alors écrire quelque chose comme

Code :

1
2
3
4
5
6
7
8
9
10
11
#include "z.h"
#include <iostream>
 
int main(int argc, char *argv[])
{
    std::cout << "id de l'instance A" << Z::A.id() << std::endl;
    std::cout << "id de l'instance B" << Z::B.id() << std::endl;
    std::cout << "id de l'instance C" << Z::C.id() << std::endl;
 
    return 0;
}

Qui affichera l'id avec lequel chacune des instances aura été construit.

[3DArchi]

Envoyé par mulfycrowh

Bonjour,

J'ai créé statiquement trois instances d'une classe Z : A B et C dans un fichier cpp.
Comment accéder à ces trois instances à partir d'un autre cpp ?

Merci

Salut,
S'il s'agit de faire

Code fichier1.c :

1
2
3
4
 
static TYPE A;
static TYPE B;
static TYPE C;

Tu ne peux utiliser leur symbole 'A', 'B', ou 'C' dans une autre unité de compilation. Les symboles ne seront utilisables que dans l'unité de compilation où ils sont définis et tu devras passer par un intermédiaire (fonction par ex) pour y accéder depuis un autre fichier.

Note que de telles variables globales vont présenter des problèmes communs aux singletons si récriés. Je te conseille la lecture du billet d'Emmanuel : Etes-vous atteint de Singletonite ?

@moldavi : le fait de définir les variables static TYPE A; dans le fichier d'en-tête aboutit à créer une variable différente dans chaque fichier compilé incluant l'en-tête. Autrement dit, dans ton exemple main et Test::FaireLeTest adressent deux jeux de variables A,B et C différents.

[moldavi]

Envoyé par 3DArchi

Autrement dit, dans ton exemple main et Test::FaireLeTest adressent deux jeux de variables A,B et C différents.

Merci pour cette précision.

A question naïve, réponse naïve.

Evidemment, je ne vois pas d'intérêt à utiliser une classe static dans plusieurs cpp.

[Bousk]

Envoyé par moldavi

Evidemment, je ne vois pas d'intérêt à utiliser une classe static dans plusieurs cpp.

A vrai dire le problème n'est pas l'intérêt ou pas, mais l'incompatibilité/impossibilité.
static signifie "unique dans l'unité de compilation", soit dans un .cpp donné
donc vouloir utiliser quelque chose d'unique à un cpp dans d'autres cpp relève au mieux de la mécompréhension et du mauvais terme utilisé, au pire d'une incongruité neuronale (ou self mind-fuck)

veut-il un singleton et donc un membre static ?
juste une méthode static ?
une déclaration extern ?
autre chose ?

[3DArchi]

Salut,

Envoyé par Bousk

static signifie "unique dans l'unité de compilation", soit dans un .cpp donné

En fait static permet deux choses distinctes :

=> étendre la durée de vie d'une variable : une variable membre d'une classe ou une variable locale à une fonction déclarées static auront une durée de vie non plus limitée à celle du contexte l'englobant mais s'étendra de leur construction jusqu'à la fin du programme.

=> uniquement pour les variables globales d'une unité de compilation (variable ayant une 'portée d'espace de nom') , réduire la portée du nom à cette unité de compilation. Ceci peut aussi être atteint en utilisant un espace de nom anonyme.