Using-declaration

Une déclaration using avec plusieurs using-déclarateurs est équivalente à une séquence correspondante de déclarations using avec un seul using-déclarateur.

Héritage des constructeurs

Si la using-declaration fait référence à un constructeur d'une base directe de la classe en cours de définition (par exemple using Base :: Base ; ), tous les constructeurs de cette base (en ignorant le contrôle d'accès) sont rendus visibles pour la résolution de surcharge lors de l'initialisation de la classe dérivée.

Si la résolution de surcharge sélectionne un constructeur hérité, il est accessible s'il serait accessible lors de la construction d'un objet de la classe de base correspondante : l'accessibilité de la déclaration using qui l'a introduit est ignorée.

Si la résolution de surcharge sélectionne l'un des constructeurs hérités lors de l'initialisation d'un objet d'une telle classe dérivée, alors le Base sous-objet duquel le constructeur a été hérité est initialisé en utilisant le constructeur hérité, et toutes les autres bases et membres de Derived sont initialisés comme par le constructeur par défaut implicitement déclaré (les initialiseurs de membres par défaut sont utilisés s'ils sont fournis, sinon l'initialisation par défaut a lieu). L'initialisation entière est traitée comme un seul appel de fonction : l'initialisation des paramètres du constructeur hérité est séquencée avant l'initialisation de toute base ou membre de l'objet dérivé.

struct B1 { B1(int, ...) {} };
struct B2 { B2(double)   {} };
int get();
struct D1 : B1
{
    using B1::B1; // hérite de B1(int, ...)
    int x;
    int y = get();
};
void test()
{
    D1 d(2, 3, 4); // OK : B1 est initialisé en appelant B1(2, 3, 4),
                   // puis d.x est initialisé par défaut (aucune initialisation n'est effectuée),
                   // puis d.y est initialisé en appelant get()
    D1 e;          // Erreur : D1 n'a pas de constructeur par défaut
}
struct D2 : B2
{
    using B2::B2; // hérite de B2(double)
    B1 b;
};
D2 f(1.0); // erreur : B1 n'a pas de constructeur par défaut

struct W { W(int); };
struct X : virtual W
{
    using W::W; // hérite de W(int)
    X() = delete;
};
struct Y : X
{
    using X::X;
};
struct Z : Y, virtual W
{
    using Y::Y;
};
Z z(0); // OK : l'initialisation de Y n'invoque pas le constructeur par défaut de X

Si le sous-objet de la classe de base Base ne doit pas être initialisé dans le cadre de l'objet Derived (c'est-à-dire si Base est une classe de base virtuelle de Derived , et que l'objet Derived n'est pas l' objet le plus dérivé ), l'appel du constructeur hérité, y compris l'évaluation de tout argument, est omis :

struct V
{
    V() = default;
    V(int);
};
struct Q { Q(); };
struct A : virtual V, Q
{
    using V::V;
    A() = delete;
};
int bar() { return 42; }
struct B : A
{
    B() : A(bar()) {} // OK
};
struct C : B {};
void foo()
{
    C c; // “bar” n'est pas invoqué, car le sous-objet V
         // n'est pas initialisé en tant que partie de B
         // (le sous-objet V est initialisé en tant que partie de C,
         //  car “c” est l'objet le plus dérivé)
}

Si le constructeur était hérité de plusieurs sous-objets de classe de base de type Base , le programme est mal formé, similaire aux fonctions membres non statiques héritées multiplement :

struct A { A(int); };
struct B : A { using A::A; };
struct C1 : B { using B::B; };
struct C2 : B { using B::B; };
struct D1 : C1, C2
{
    using C1::C1;
    using C2::C2;
};
D1 d1(0); // mal formé : constructeur hérité de différents sous-objets de base B
struct V1 : virtual B { using B::B; };
struct V2 : virtual B { using B::B; };
struct D2 : V1, V2
{
    using V1::V1;
    using V2::V2;
};
D2 d2(0); // OK : il n'y a qu'un seul sous-objet B.
          // Ceci initialise la classe de base virtuelle B,
          //   qui initialise la classe de base A
          // puis initialise les classes de base V1 et V2
          //   comme par un constructeur par défaut généré automatiquement

Comme pour les déclarations using de toute autre fonction membre non statique, si un constructeur hérité correspond à la signature de l'un des constructeurs de Derived , il est masqué lors de la recherche par la version trouvée dans Derived . Si l'un des constructeurs hérités de Base se trouve avoir la signature qui correspond à un constructeur de copie/déplacement de Derived , cela n'empêche pas la génération implicite du constructeur de copie/déplacement de Derived (qui masque alors la version héritée, similairement à using operator= ).

struct B1 { B1(int); };
struct B2 { B2(int); };
struct D2 : B1, B2
{
    using B1::B1;
    using B2::B2;
    D2(int); // OK : D2::D2(int) masque à la fois B1::B1(int) et B2::B2(int)
};
D2 d2(0);    // appelle D2::D2(int)

Dans une classe template , si une déclaration using fait référence à un nom dépendant , il est considéré comme nommant un constructeur si le nested-name-specifier a un nom terminal identique au unqualified-id .

template<class T>
struct A : T
{
    using T::T; // OK, hérite des constructeurs de T
};
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // OK, hérite des constructeurs de A<U>
    using T::A;    // n'hérite pas du constructeur de T
                   // même si T peut être une spécialisation de A<>
};

Introduction des énumérateurs délimités

En plus des membres d'un autre espace de noms et des membres des classes de base, la déclaration using peut également introduire les énumérateurs des énumérations dans les portées de namespace, de bloc et de classe.

Une déclaration using peut également être utilisée avec des énumérateurs non délimités.

enum class button { up, down };
struct S
{
    using button::up;
    button b = up; // OK
};
using button::down;
constexpr button non_up = down; // OK
constexpr auto get_button(bool is_up)
{
    using button::up, button::down;
    return is_up ? up : down; // OK
}
enum unscoped { val };
using unscoped::val; // OK, though needless

La sémantique des constructeurs hérités a été modifiée rétroactivement par un rapport de défaut contre C++11 . Auparavant, une déclaration de constructeur hérité provoquait l'injection d'un ensemble de déclarations de constructeurs synthétisés dans la classe dérivée, ce qui entraînait des copies/déplacements redondants d'arguments, avait des interactions problématiques avec certaines formes de SFINAE, et dans certains cas pouvait être impossible à implémenter sur les ABI majeurs. Les compilateurs plus anciens peuvent encore implémenter l'ancienne sémantique.

struct B1
{
    B1(int);
};
struct D1 : B1
{
    using B1::B1;
    // The set of candidate inherited constructors is 
    // 1. B1(const B1&)
    // 2. B1(B1&&)
    // 3. B1(int)
    // D1 has the following constructors:
    // 1. D1() = delete
    // 2. D1(const D1&) 
    // 3. D1(D1&&)
    // 4. D1(int) <- inherited
};
struct B2
{
    B2(int = 13, int = 42);
};
struct D2 : B2
{
    using B2::B2;
    // The set of candidate inherited constructors is
    // 1. B2(const B2&)
    // 2. B2(B2&&)
    // 3. B2(int = 13, int = 42)
    // 4. B2(int = 13)
    // 5. B2()
    // D2 has the following constructors:
    // 1. D2()
    // 2. D2(const D2&)
    // 3. D2(D2&&)
    // 4. D2(int, int) <- inherited
    // 5. D2(int) <- inherited
};

Les expansions de paquets dans les déclarations using permettent de former une classe qui expose les membres surchargés de bases variadiques sans récursion :

template<typename... Ts>
struct Overloader : Ts...
{
    using Ts::operator()...; // expose operator() de chaque base
};
template<typename... T>
Overloader(T...) -> Overloader<T...>; // guide de déduction C++17, non requis en C++20
int main()
{
    auto o = Overloader{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}