====== Définition de types dans une classe ======

Il est possible de définir des types ou des alias de types au sein d'une classe.

L'intérêt de pouvoir définir un type au sein d'une classe peut-être notamment justifié :

   * par le fait que le type ainsi défini n'est //a priori// destiné qu'à être manipulé par les fonctions membres de la classe en question,
   * par le souhait de simplifier le nommage de ces types et d'éviter un éventuel conflit,
   * par le fait que le type ainsi défini possède éventuellement un nom générique comme par exemple ''iterator'' ou ''const_iterator'' pour les classes implantant des containeurs mais dont la définition dépend de la structure de donnée interne de l'objet, 
   * par le fait que le type ainsi défini pour être rendu accessible à la seule classe, éventuellement aux classes dérivées ou aux classes ou fonctions amies,

La liste précédent étant indicative et aucunement limitative. Dans de nombreux cas, il est pertinent de définir un type ou un alias de type au sein d'un classe.

===== Syntaxe de la déclaration de types =====

Les déclarations de type s'effectuent au sein de la classe. L'accessibilité de ces éléments dépend directement de l'attribut ''public'', ''protected'' ou ''private'' qui éclaire la section dans laquelle ces éléments ont été définis.

Le code suivant défini une classe ''Value'' qui a été définie au sein d'une classe ''StaticArray''. La classe ''Value'' peut-être accédé par une fonction externe à la classe ''StaticArray'' puisqu'elle a été déclarée ''public''. Si elle avait été déclarée comme ''private'', seuls les fonctions membres et les définitions de champs, de constantes ou de te types auraient pu faire référence à cette classe ''Value''.

<code cpp>
class StaticArray
{
public:
    class Value
    {
    private: 
        int m_value;
    public:
        Value(int aValue): m_value(0)
        {
            if(aValue < -10)
                m_value = -10;
            else if(aValue > 10)
                m_value = 10;
        }
    };      
          
private:
    Value* m_array;

public: 
    typedef Value value_type;
    typedef value_type& reference_type;
    typedef const value_type& const_reference_type;
    
    reference_type get(int index) { return m_array[index]; }    
    const_reference_type get(int index) const { return m_array[index]; }    
    
    StaticArray(int theLength, int* theValues): 
        m_array(new Value[theLength])
    {
        for(int index = 0; index < theLength; index ++)
            m_array[index] = theValues[index];        
    }
};
</code>

Cette classe définit aussi deux alias de type, ceux-ci sont ''value_type'' qui définit le nom ''value_type'' comme un alias du nom de classe ''Value'' ainsi que ''reference_type'' qui définit un alias du type ''value_type&'', c'est-à-dire ''Value&''.


Ces définitions peuvent être utilisées au sein de la classe sans avoir être préfixées. Cependant, si la définition est accessible (cf. [[in204:cpp:syntax:class|règles d'accessibilité]]), il est possible d'accéder aux définitions dans la classe ''StaticArray'' en préfixant ces définitions par ''StaticArray::''.

<code cpp>
    StaticArray array(3, {2, 11, 7 });
    StaticArray::value_type value(8);   
    
    array.get(2) = value;
</code>