Programmation C-C++/Les espaces de nommage/Déclaration using

Cours de C/C++
^
C++ : Les espaces de nommage
	Définition des espaces de nommage
	Déclaration using
	Directive using
Livre original de C. Casteyde

Les déclarations using permettent d'utiliser un identificateur d'un espace de nommage de manière simplifiée, sans avoir à spécifier son nom complet (c'est-à-dire le nom de l'espace de nommage suivi du nom de l'identificateur).

Syntaxe des déclarations using

La syntaxe des déclarations using est la suivante :

using identificateur;

où identificateur est le nom complet de l'identificateur à utiliser, avec qualification d'espace de nommage.

Exemple 11-7. Déclaration using

namespace A
{
    int i;        // Déclare A::i.
    int j;        // Déclare A::j.
}

void f(void)
{
    using A::i;   // A::i peut être utilisé sous le nom i.
    i=1;          // Équivalent à A::i=1.
    j=1;          // Erreur ! j n'est pas défini !
    return ;
}

Les déclarations using permettent en fait de déclarer des alias des identificateurs. Ces alias doivent être considérés exactement comme des déclarations normales. Cela signifie qu'ils ne peuvent être déclarés plusieurs fois que lorsque les déclarations multiples sont autorisées (déclarations de variables ou de fonctions en dehors des classes), et de plus ils appartiennent à l'espace de nommage dans lequel ils sont définis.

Exemple 11-8. Déclarations using multiples

namespace A
{
    int i;
    void f(void)
    {
    }
}

namespace B
{
    using A::i;  // Déclaration de l'alias B::i, qui représente A::i.
    using A::i;  // Légal : double déclaration de A::i.

    using A::f;  // Déclare void B::f(void),
                 // fonction identique à A::f.
}

int main(void)
{
    B::f();      // Appelle A::f.
    return 0;
}

L'alias créé par une déclaration using permet de référencer uniquement les identificateurs qui sont visibles au moment où la déclaration using est faite. Si l'espace de nommage concerné par la déclaration using est étendu après cette dernière, les nouveaux identificateurs de même nom que celui de l'alias ne seront pas pris en compte.

Exemple 11-9. Extension de namespace après une déclaration using

namespace A
{
    void f(int);
}

using A::f;            // f est synonyme de A::f(int).

namespace A
{
    void f(char);      // f est toujours synonyme de A::f(int),
                       // mais pas de A::f(char).
}

void g()
{
    f('a');            // Appelle A::f(int), même si A::f(char)
                       // existe.
}

Si plusieurs déclarations locales et using déclarent des identificateurs de même nom, ou bien ces identificateurs doivent tous se rapporter au même objet, ou bien ils doivent représenter des fonctions ayant des signatures différentes (les fonctions déclarées sont donc surchargées). Dans le cas contraire, des ambiguïtés peuvent apparaître et le compilateur signale une erreur lors de la déclaration using.

Exemple 11-10. Conflit entre déclarations using et identificateurs locaux

namespace A
{
    int i;
    void f(int);
}

void g(void)
{
    int i;        // Déclaration locale de i.
    using A::i;   // Erreur : i est déjà déclaré.
    void f(char); // Déclaration locale de f(char).
    using A::f;   // Pas d'erreur, il y a surcharge de f.
    return ;
}

Ce comportement diffère de celui des directives using. En effet, les directives using reportent la détection des erreurs à la première utilisation des identificateurs ambigus.

Utilisation des déclarations using dans les classes

Une déclaration using peut être utilisée dans la définition d'une classe. Dans ce cas, elle doit se rapporter à une classe de base de la classe dans laquelle elle est utilisée. De plus, l'identificateur donné à la déclaration using doit être accessible dans la classe de base (c'est-à-dire de type protected ou public).

Exemple 11-11. Déclaration using dans une classe

namespace A
{
    float f;
}

class Base
{
    int i;
public:
    int j;
};

class Derivee : public Base
{
    using A::f;      // Illégal : f n'est pas dans une classe
                     // de base.
    using Base::i;   // Interdit : Derivee n'a pas le droit
                     // d'utiliser Base::i.
public:
    using Base::j;   // Légal.
};

Dans l'exemple précédent, seule la troisième déclaration est valide, parce que c'est la seule qui se réfère à un membre accessible de la classe de base. Le membre j déclaré sera donc un synonyme de Base::j dans la classe Derivee.

En général, les membres des classes de base sont accessibles directement. Quelle est donc l'utilité des déclarations using dans les classes ? En fait, elles peuvent être utilisées pour rétablir les droits d'accès, modifiés par un héritage, à des membres de classes de base. Pour cela, il suffit de placer la déclaration using dans une zone de déclaration du même type que celle dans laquelle le membre se trouvait dans la classe de base. Cependant, comme on l'a vu ci-dessus, une classe ne peut pas rétablir les droits d'accès d'un membre de classe de base déclaré en zone private.

Exemple 11-12. Rétablissement de droits d'accès à l'aide d'une directive using

class Base
{
public:
    int i;
    int j;
};

class Derivee : private Base
{
public:
    using Base::i;  // Rétablit l'accessibilité sur Base::i.
protected:
    using Base::i;  // Interdit : restreint l'accessibilité
                    // sur Base::i autrement que par héritage.
};

Certains compilateurs interprètent différemment le paragraphe 11.3 de la norme C++, qui concerne l'accessibilité des membres introduits avec une déclaration using. Selon eux, les déclarations using permettent de restreindre l'accessibilité des droits et non pas de les rétablir. Cela implique qu'il est impossible de redonner l'accessibilité à des données pour lesquelles l'héritage a restreint l'accès. Par conséquent, l'héritage doit être fait de la manière la plus permissive possible, et les accès doivent être ajustés au cas par cas. Bien que cette interprétation soit tout à fait valable, l'exemple donné dans la norme C++ semble indiquer qu'elle n'est pas correcte.

Quand une fonction d'une classe de base est introduite dans une classe dérivée à l'aide d'une déclaration using, et qu'une fonction de même nom et de même signature est définie dans la classe dérivée, cette dernière fonction surcharge la fonction de la classe de base. Il n'y a pas d'ambiguïté dans ce cas.