Bonjour,
Comment rendre une variable accessible aux autres classes ?
extern ? (je ne trouve pas d'exemple!)
Merci d'avance.
Version imprimable
Bonjour,
Comment rendre une variable accessible aux autres classes ?
extern ? (je ne trouve pas d'exemple!)
Merci d'avance.
slt,
bah en fait si ta variable est un attribut d'une classe je pense que le plus simple pour la rendre accessible à l'extérieur ca serait de faire une méthode get du type
typeDeLaVariable getVariable();
enfin j'ai surment mal compris la question... sinon c'est ca que je ferai :D
:lahola:
Un travail vite fait n'est pas forcément bâclé.
j'ai une variable char MaVariable; utilisé principalement dans MaClasseA,
mais dans MaclasseOption je peux la modifier et ya t il un moyen de la modifier autrement que de passer par MaClasseA->MaVariable, je voudrais que cette variable soit accessible sans déclarer le MaClasseA.h
est ce possible ?
juste une petite question... c'est quoi l'intérêt d'utiliser une variable de cette classe sans la déclarer ? tu vas en faire quoi de cette variable ?
de plus, si tu ne déclares pas la classe qui contient cette variable elle n'existe pas donc c'est pas possible de la changer.
:lahola:
Un travail mérite une rémunération proportionnelle à son utilité.
Est-ce que ta variable est globale au programme, ou est-elle propre à ta classe MyClassA (i.e. il existe une instance de ta variable dans chaque instance de MyClassA) ?
Bon, ben si tu ne veux pas inclure ton MaClasseA.h dans tes autres sources, tu peux essayer de mettre cette variable dans une autre classe (p.ex. ClassePubliqueA, déclarée dans un autre header) dont hérite MaClasseA. Ainsi tu inclus cet header dans ton second fichier (MaClasseOption.h). Après tu as de toute façon besoin d'au moins un pointeur sur l'instance de MyClasseA pour accéder à sa partie "ClassePubliqueA".
Exemple (non testé):
ClassePublique.h
MaClasseA.h (Exemple d'initialisation de MaVariable à 10)Code:
1
2
3
4
5 class ClassePublic { public: int MaVariable; ClassePublic() : MaVariable(0) {}; };
MaClasseOption.h (accès à MaVariable depuis un pointer)Code:
1
2
3
4 #include "ClassePublique.h" class MaClasseA : public ClassePublique { // Ton code sauf MaVariable puisque déjà déclarée dans ClassePublique };
Tu appelles ainsi ta classe MaClasseOption avec un pointeur sur MaClasseA mais sans que MaClasseOption ne connaisse la définition de MaClasseA:Code:
1
2
3
4
5
6 #include "ClassePublique.h" class MaClasseOption { void AfficheMaVariable(ClassePublique* A) { if (A) cerr<<A->MaVariable<<endl; } };
Je ne sais pas si c'est très clair...Code:
1
2
3
4
5
6
7
8
9
10
11
12 #include "MaClasseA.h" #include "MaClasseOption.h" void main() { MaClasseA *toto=new MaClasseA(); if (toto) { toto->MaVariable=10; // Donne une valeur à MaVariable MaClasseOption test; test.AfficheMaVariable(toto); // Affiche la valeur (10) } delete toto; toto=NULL; }
Si tu peux te contenter d'une seule instance de ta variable MaVariable partagée par tous tes objets, alors tu peux simplement la déclarer comme statique. Ainsi tu peux y accéder juste en déclarant ClassePublique et sans pointeur sur MaClasseA:
ClassePublique.h
ClassePublique.cppCode:
1
2
3
4 class ClassePublic { public: static int MaVariable; };
MaClasseA.h est identiqueCode:ClassePublique::MaVariable=0; // Initialise la variable au démarrage de l'application
En fait, la variable appartient à la classe et pas à une instance. Tu pourrais donc même écrire:Code:
1
2
3
4
5
6
7
8
9
10
11 #include "MaClasseA.h" #include "MaClasseOption.h" void main() { MaClasseA *toto=new MaClasseA(); if (toto) { toto->MaVariable=10; MaClasseOption test; test.AfficheMaVariable(); // Plus besoin du pointeur } delete toto; toto=NULL; }
Code:
1
2
3
4
5
6 #include "ClassePublique.h" void main() { MaClasseOption test; ClassePublique::MaVariable=10; // Donne une valeur à MaVariable (globale) test.AfficheMaVariable(); // Affiche la valeur (10) }