Instanciation d'un enum indépendamment de sa déclaration

Bonjour,

je cherche à ne pas instancier mon enum au moment de sa déclaration.
Est ce que c'est possible ? Si oui quelle est la syntaxe ?

Voilà ce que j'aimerai faire :

Code:

---

1 2	enum toto; toto{0,1,2,3};

---

j'ai trouvé que je pouvais faire ça (ça compile)

Code:

---

enum toto:int;

---

Mais après comment instancier mon enum ?

Code:

---

toto{0,1,2,3};

---

ne compile pas....

Aucun de mes collègues n'a plus d'idées que moi !!!
Merci pour votre aide !!
Pascale38

L'instanciation c'est pour des classes ou des structures pas pour des enum.
Même conceptuellement, l'instanciation d'un enum me laisse perplexe.
Pouvez-vous nous donner un cas d'utilisation concrète de ce "concept" ?

Désolée si je n'utilise pas le bon terme, à vrai dire je ne sais pas comment on dit pour un enum ???
Le fait de lui affecter ses valeurs ???
Bref ça n'est pas le sujet de toutes façons...

Quand à l'utilité, c'est un peu long à expliquer...
Disons que ça me permettrait de déclarer mon enum dans une classe mère et de déclarer ses valeurs dans les classes filles....

Entre temps je crois que j'ai trouvé, c'est tout bête en fait, il fallait juste trouver la bonne syntaxe :

Code:

---

1 2	enum toto:int; enum toto:int{0,1,2,3};

---

je vérifie que ça marche et je mettrai à résolu si c'est le cas.

Pascale38

Salut,

la réponse courte :
Avec les énumérations simples, tu ne peux pas le faire. En C++11, on dispose des énumération fortement typées (strong enums) qui permettent une déclaration anticipée , mais cela ne va sans doute pas t'aider.

La réponse longue implique d'abord de se poser une question importante :

Citation:

---

pourquoi voudrais tu déclarer dans la classe mère une énumération qui ne serait définie que dans la classe fille :question:

---

A mon sens, si tu est confronté à un tel besoin avec une approche orientée objet, c'est sans aucun doute le symptôme d'un problème de conception qu'il s'agirait de résoudre ;)

Dans une approche générique (qui utilise les template), tu n'aurais pas forcément besoin de la déclaration anticipée, la simple existence de certains symboles spécifiques (par exemple : MAX) devrait sans doute te suffire ;)

Plus sérieusement, le but d'une énumération est d'associer à la compilation un identifiant (comprends : un terme qui représente quelque chose de spécifique) "qui ait du sens" à une valeur numérique particulière. Les trois code suivants (par ordre de préférence) sont donc quasiment équivalents(*)

Code:

---

1 2 3 4 5 6

enum { first = 1, second = 2, /* ... */ last = 0xFF };

---

Code:

---

1 2 3 4

static const int first = 1; static const int second = 2; /* ... */ static const int last = 0xFF;

---

Code:

---

1 2 3 4

#define first 1 #define second 2 /* ... */ define last 0xFF

---

(*) du moins, au niveau du résultat, car la version qui utilise define ne permet aucune vérification de type et la version à base d'énumération permet au compilateur de vérifier que toutes les valeurs fassent partie "du meme groupe" et que toutes les valeurs d'un groupe soient testées (par exemple dans le cadre d'un switch... case).

Seulement, une restriction de l'énumération "classique" est (entre autres) que l'on ne peut pas en faire de déclaration anticipée comme nous le ferions pour une classe ou une structure.

C'est pourquoi C++11 est arrivé avec les énumérations fortement typée qui prennent la forme de

Code:

---

1 2 3

enum class NomEnumeration{ valeursEnumerees };

---

qui peuvent (entre autres) être déclarées par anticipation, permettant un code proche de
(monEnum.hpp)

Code:

---

1 2 3

enum class MonEnumeration{ /* ... */ };

---

(autreFichier.hpp)

Code:

---

1 2 3 4 5 6

#ifndef AUTREFICHIER_HPP #define AUTREFICHIER_HPP enum class MonEnumeration; void foo(MonEnumeration); #endfi AUTREFICHIER_HPP

---

(fichier.cpp)

Code:

---

1 2 3 4 5 6

#include <autreFichier.hpp> #include <monEnum.hpp> void foo(MonEnumeration valeur){ /* ... utilisation des valeurs énumérées */ }

---

Mais, cela ne résoudra pas ton probleme car, si tu as une classe de base et une classe dérivée prenant la forme de

Code:

---

1 2 3 4 5 6 7 8

class Base{ /* ... */ /* nous aurions peut etre la déclaration anticipée ici ??? */ }; class Derivee : public Base{ /* ... */ /* et donc la définition de l'énumération ici ??? */ };

---

la déclaration anticipée de ton énumération fortement typée serait de type Base::MonEnumeration alors que la définition que l'on trouverait dans Derivee serait de type Derivee::MonEnumeration et, pour notre malheur, cela correspond bel et bien à deux type totalement différent :P

Tout cela me ramène donc à ma question de départ : pourquoi voudrais tu faire une telle chose :question: as-tu vraiment besoin d'utiliser des valeurs énumérées différentes dans chaque classe dérivée :question: Ne peux-tu (au pire) pas définir ton énumération dans la classe de base :question: Ne pourrais tu pas éviter le recours à ton énumération grâce à des comportements polymorphes (fonctions virtuelles), voir, à un double dispatch :question:

Pour de plus amples détails, tu peux aussi regarder dans une référence: enum sur cppreference.com