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.

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.

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];        
    }
};

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

    StaticArray array(3, {2, 11, 7 });
    StaticArray::value_type value(8);   
 
    array.get(2) = value;