^ [[rvalue_et_lvalue|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[inference_de_type|Chapitre suivant]] ^

<note warning>Les chapitres suivants sont encore en cours de rédaction, voire à l'état d'ébauche. N’hésitez pas a faire des remarques ou poser des questions sur le forum de [[http://zestedesavoir.com/forums/|Zeste de Savoir]] ou de [[http://openclassrooms.com/forum/sujet/nouveau-cours-c-moderne|OpenClassroom]].</note>

====== Constantes et énumérations ======

===== constantes =====

litterale = valeur ecrite directement dans le code. Parfois, une litterale a un sens particulier, par exemple une constante de physique ou de mathematique. Il est classique de nommer cette valeur pour la lisibilite = constante.

Syntaxe tres specifique :

<code cpp>
template<typename T>
constexpr T pi = T(3.1415926535897932385);
</code>

Signifie que l'on cree un constante "pi", qui prend la valeur "3.1415...". Le type de cette constante depend de T, qui représente un type fondamental, comme int, double, etc...


Une constante est simplement une variable dont la valeur ne change pas. 

<note>**Anciennes syntaxes**

Sans template :

<code cpp>
const double pi { 3.1415926535897932385 };
</code>

Très très old school : avec #define
</note>



===== Les enumérations =====

Une enumeration est une liste de valeurs constantes. Chaque valeur a un nom et l'ensemble des noms sont regroupes dans le nom de l'enumeration.

Pour declarer une enumeration et des valeurs, la syntaxe generale est la suivante :

<code cpp>
enum class NOM_ENUMERATION {
    LISTE_DE_VALEURS
};
</code>

Le nom de l'enumeration est "NOM_ENUMERATION". Par exemple, pour definir une enumeration de couleurs (vide pour le moment) :

<code cpp>
enum class Couleur {
    ...
};
</code>

La liste de valeurs est une liste d'identifiants separees par des virgules. 

<code cpp>
NOM_VAlEUR_1, NOM_VALEUR_2, ..., NOM_VALEUR_N
</code>

Par exemple :

<code cpp>
enum class Couleur {
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet
};
</code>

(Note : pour rappel, les retours a la ligne sont utilises librement en C++. Cette liste est definie sur une seule ligne, mais ca serait equivalent d'ecrire chaque valeur sur une ligne differente).

Dans cet exemple, l'enumeration s'appelle ''Couleur''. Elle contient 8 valeurs : ''Noir'' a ''Violet''.

Une enumeration definie un nouveau type, il est donc possible de definir une variable du type "NOM_ENUMERATION". Pour utiliser les valeurs definies dans une enumeration, il faut simplement utiliser l'operateur de portee ''::'' (scope operator).

<code cpp>
NOM_ENUMERATION NOM_VARIABLE {};
NOM_VARIABLE = NOM_ENUMERATION :: NOM_VALEUR;
</code>

Par exemple :

<code cpp>
enum class Couleur {
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet
};

Couleur une_couleur { Couleur::Rouge };  // initialisation
une_couleur = Couleur::Bleu;             // affectation
</code>

Les valeurs des enumerations peuvent etre converties en nombre entier, en utilisant l'operateur de conversion "static_cast" :

<code cpp>
const auto c = static_cast<int>(une_couleur);  // convertie le type "Couleur" en type "int"
</code>

Par defaut, les valeurs de l'enumeration sont converties en entier selon leur ordre dans l'enumeration, en commencant de 0 :

<code cpp>
std::cout << static_cast<int>(Couleur::Noir) << std::endl;
std::cout << static_cast<int>(Couleur::Blanc) << std::endl;
std::cout << static_cast<int>(Couleur::Rouge) << std::endl;
std::cout << static_cast<int>(Couleur::Vert) << std::endl;
</code>

affiche :

<code>
0
1
2
6
</code>

Il est possible de definir la valeur entiere correspondant a chaque valeur de l'enumeration en utilisant =. Les valeurs qui ne sont pas explicitement definies prennent la valeur precedente + 1.

<code cpp>
enum class Couleur {
    Noir,         // prend automatiquement la valeur 0
    Blanc,        // prend automatiquement la valeur 1
    Rouge = 100,  // prend explicitement la valeur 100
    Jaune = 200,  // prend explicitement la valeur 200
    Bleu,         // prend automatiquement la valeur 201
    Orange,       // prend automatiquement la valeur 202
    Vert,         // prend automatiquement la valeur 203
    Violet        // prend automatiquement la valeur 204
};

std::cout << static_cast<int>(Couleur::Rouge) << std::endl;
std::cout << static_cast<int>(Couleur::Vert) << std::endl;
</code>

affiche :

<code>
100
203
</code>

Il est également possible de convertir un nombre entier en valeur d'une enumeration avec "static_cast".

<code cpp>
const auto c = static_cast<Couleur>(1);
assert(c == Couleur::Blanc);
</code>

<note>**Ancienne syntaxe**

Meme syntaxe, sans le mot-clé ''class''. 

<code cpp>
enum Couleur {
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet
};

Couleur une_couleur { Rouge };  // initialisation
une_couleur = Bleu;             // affectation
</code>

Definit les enum dans la portee globale (//unscoped enum//). "Dans la portée globale" signifie qu'il n'est pas nécessaire d'indiquer la portée ''Couleur::''. Cela peut provoquer des conflits, par exemple :

<code cpp>
enum Pion {
    Noir, Blanc
};

enum Couleur {
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet // confit
};
</code>
affiche les erreurs suivantes :

<code>
main.cpp:8:5: error: redefinition of enumerator 'Noir'
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet // confit
    ^
main.cpp:4:5: note: previous definition is here
    Noir, Blanc
    ^
main.cpp:8:11: error: redefinition of enumerator 'Blanc'
    Noir, Blanc, Rouge, Jaune, Bleu, Orange, Vert, Violet // confit
          ^
main.cpp:4:11: note: previous definition is here
    Noir, Blanc
          ^   
</code>

Ce type d'énumération ne nécessite pas de conversion explicite avec ''static_cast'' pour convertir en entier, les valeurs sont convertie implicitement (promotion) entiers.
</note>


^ [[rvalue_et_lvalue|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[inference_de_type|Chapitre suivant]] ^