bonjour,
soyez indulgent sur ma présentation, c'est mon 2e post (je suis ouvert à tout conseils)
Je suis sous windows8 et suis actuellement face à l'impossibilité d'installer ne serait-ce qu'un IDE comme "eclipse".
"JRE requis" >> le support windows expliquant qu'il est installé nativement sur ttes ces plateform mais pas activé ou qqch du genre...
Bref, je vous passe les détails.
J'utilise alors des compilateurs en ligne:
- Clang (3 & 3.2)
- GCC (4.3.4, 4.5.1, 4.5.3, 4.6.3, 4.7, 4.7.2 & 4.8 prerelease)
- Intel ICC 13.0.1
- Microsoft (VC++ alpha CTP, Nov 2012)
supportant le C++4.3.2, 4.8.1, C++11
J'ai parcouru plusieurs cours C++ sur les fondamentaux:
int, short int, unsigned int, long int, unsigned long **// entiers ***********// intégral ******// arithmétiques //fondamentaux
enum ******// énuméraion ******************// entiers ***********//************//***********//
char, signed char, unsigned char, wchar_t ********// caractères *********// ***********//***********//
bool ************************************// booléen ***********// ***********//***********//
float, double, long double ********************// réels **************************// ***********//
void ******// uniquement pour les valeur de retour et les types de pointeurs **************************//
// le reste ****************************************************************************// dérivés
Ce que j'ai retenu concernant les énumérations, c'est qu'elle est un type de la catégorie des entiers, représentent une liste de constantes de type entier (cet ensemble sera du type définit par enum), et peut optionnellement être nommé, que les valeur par défaut sont les indices d'un tableau, et peuvent être initialisé, qu'une variable de type enum, n'est par définition pas constante, mais bel et bien une variable. Et pour finir, les énumérateurs (composants de la liste) ne sont pas accessible comme des membres (classe.membre ou classe->membre), mais uniquement comme de simples constantes.
FAUX: une énumération est aujourd'hui accessibleEnvoyé par koala01
D'après les sous-ensembles que j'ai indiqué plus haut, j'en déduit que les énumérations imbriqués sont possible.
...et bien non
Néanmoins, je me trouve face à plusieurs interrogations:
- est-ce une seconde syntaxe valide de déclaration ?
- les constantes d'une même liste sont-elles toute de type identique ?
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9 enum leType {PARAMETRE1(a), /*...*/}; // à priori invalide (contrairement aux déclaration: "int nombre(451);" ) //au lieu de: enum leType {PARAMETRE1=a, /*...*/}; //ou encore enum leType {PARAMETRE1=a, /*...*/} laVariable; // à priori validde (comme une structure) //au lieu de: enum leType {PARAMETRE1=a, /*...*/}; leType laVariable;
Non, elles peuvent être de types différents, contrairement à leurs noms (où c'est une obligation), mais se doivent d'être de type entier (ne pas confondre avec intégral, une catégorie plus large) et ne peut être de type énumération également. Elle peuvent tout de même être de type booléennes ou caractères, mais seront converti sous forme d'entier numérique à la compilation.
- est-ce un type entier en particulier, ou le compilateur le détermine suivant le contexte ?
C'est le compilateur qui détermine le type de chaque constantes suivant le contexte, de même que pour le type de l'énumération: il choisit un type capable de stocker le plus grand. Attention, ce type est alors un type unique rattaché au nom de l'énumération, et cette dernière est typé.
- d'après mes essais en ligne, une variable de type enum peut prendre des valeurs non contenu dans sa liste.
****dans ce cas, quelle est l'intérêt par rapport à une déclaration simple avec const ?
****(j'ai pourtant cru comprendre que ce problème arrivait en C, mais pas en C++)
Une variable de type énumération ne peut pas prendre de valeur autre que celle de sa liste, ds le cas contraire, le compilateur est défaillant.
complément tiré des réponses ci-dessous:
- Les énumérations apportent une sécurité supplémentaire:
Seul des valeurs numériques entières seront utilisé par l'énumération. Ces valeurs sont rattaché à un type propre. Une variable de ce type ne peut prendre d'autres valeurs que celles des énumérateurs.
Partager