Discussion :

[tintin72]

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 :

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

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 :

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

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

[Flodelarab]

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.

[nikko34]

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

[tintin72]

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.

[Flodelarab]

Mais pourtant int et double sont des types aussi non ?

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

[koala01]

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 :

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
 
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 , en dehors de toute directive d'utilisation d'espace de nommage (using namespace...), tu devra instancier un objet sous la forme de

Code :

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

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 :

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

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

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 :

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

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)