enum dans une classe ?

Bonjour,

Je viens de m'apercevoir d'une caractéristique bizzare de
enum lorsqu'il est déclaré dans une classe et utilisé dans
une fonction membre statique. Par ex:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class MaClasse { enum{VAR1, VAR2, VAR3}; int uneVar; double uneAutre; etc... public:   MaClasse(); etc...   static void staticFunc(void *data); }

---

maintenant dans la fonction membre statique

Code:

---

1 2 3 4 5 6 7

void MaClasse::staticFunc(void *data) { MaClasse *p = (MaClasse*)data; p->uneVar; p->uneAutre = VAR3; //ça marche !!?? }

---

Normalement il faudrait utiliser le pointeur p->VAR3 pour
accéder aux variable membre privées, non ?
En tous cas je n'ai aucune erreur du compilo et mon
appli semble fonctionner.

Est ce que quelqu'un pourrait me dire si c'est normal ?

Merci

Je pense que tu ne comprends pas ce que tu fais.
Le type énuméré est une façon d'utiliser des nombres entiers sans le dire. Au lieu de dire "au bleu correspond 0","au blanc correspond 1","au rouge correspond 2".... on énumère les mots qui tiendront lieu de valeur.

"Définir un objet" n'est pas "posséder un objet".
Ton mot clé "enum" définit une série de valeurs mais ce n'est pas un membre.

A priori (mais c a vérifier), tu changes la portée de la définition de ton type énuméré en le mettant dans la classe mais tu ne décris pas plus ton objet que tu as commencer à décrire en écrivant le mot clé class.

c'est normal, ton enum n'est pas une variable membre, c'est un type.

Citation:

---

c'est normal, ton enum n'est pas une variable membre, c'est un type.

---

Mais pourtant int et double sont des types aussi non ?
Le truc c'est que je pensais que tout ce qui est dans la partie private
ou protected d'une classe n'était plus accessible quelque soit le type.

Salut,

Toute définition de type à l'intérieur d'une classe n'a un effet que strictement similaire à ce qui se passe quand on défini un type dans un espace de nommage...

Cela signifie que tu dois indiquer la portée, mais tu garde tout à fait l'acces à ce type:

Par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

namespace MonEspace { class MaClass { public: MaClass(){} /*...*/ }; enum lenum { lavaleur1, lavaleur2 /*,   ... */ }; };

---

Si tu as la déclaration comme ci-dessus (et, bien sur, l'implémentation qui va avec :D, en dehors de toute directive d'utilisation d'espace de nommage (using namespace...), tu devra instancier un objet sous la forme de

Code:

---

MonEspace::MaClass objet;

---

Si tu déclare un type - quel qu'il soit (énum, class...) - en l'imbriquant dans une classe, tu devra tout simplement indiquer la portée de la meme manière, à savoir qu'avec une classe du genre de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

class LaClasseSommet { class LaClasseImbriquee { public: LaClasseImbriquee(){} /*...*/ }; enum lenumimbriquee { val1, val2 /* ,   ... */ } public: LaClasseSommet(){} void LaFonction(); /*...*/ }

---

Au sein de la classe, la portée est... celle de la classe, ce qui fait que LaFonction sera implémentée sous la forme de

Code:

---

1 2 3 4 5 6 7

void LaClasseSommet::LaClasseSommet { /* on a directement acces à l'énumération */ lenumimbriquee ee=val1; /* tout comme à la classe imbriquée */ LaClassImbriquee objet; }

---

mais, par contre, dans une fonction qui n'est pas déjà dans la portée de LaClasseSommet, l'acces est là, mais la portée doit etre indiquée.

Code:

---

1 2	LaClasseSommet::LaClasseImbriquee lobjet; LaClasseSommet::lenumimbrique lava=LaClasseSommet::val1;

---

L'avantage étant, tout comme l'utilisation d'un espace de nommage, que tu "limite" l'acces au type imbriqué à la portée... ce qui fait que tant le nom de la classe ou de l'énumération ou le terme représentant la valeur énumérée pourra être réutilisé (dans une autre classe ou un autre espace de nommage) :D

Citation:

---

Envoyé par tintin72

Mais pourtant int et double sont des types aussi non ?

---

:D tu n'as pas lu ma réponse.

Oui, int et double sont des types.
Mais quand tu écris "int i", tu ne définis pas un type mais une variable de type "int"

Quand tu écris enum MonType{valeur1,valeur2} tu definis un type.
Quand tu écris "MonType i;", tu définis une variable de type MonType.

Ici, tu n'as pas définis un membre de ta classe mais tu as définis un type utilisable dans ta classe (pour créer des membres ou non, d'ailleurs).