Using-declaration

Eine using-Deklaration mit mehr als einem using-Deklarator entspricht einer entsprechenden Folge von using-Deklarationen mit jeweils einem using-Deklarator.

Vererbende Konstruktoren

Wenn die using-Deklaration auf einen Konstruktor einer direkten Basis der definierten Klasse verweist (z.B. using Base :: Base ; ), werden alle Konstruktoren dieser Basis (unter Ignorierung des Member-Zugriffs) für die Überlagerungsauflösung bei der Initialisierung der abgeleiteten Klasse sichtbar gemacht.

Wenn die Überladungsauflösung einen geerbten Konstruktor auswählt, ist er zugreifbar, wenn er zugreifbar wäre, wenn er zum Konstruieren eines Objekts der entsprechenden Basisklasse verwendet würde: Die Zugreifbarkeit der using-Deklaration, die ihn eingeführt hat, wird ignoriert.

Wenn die Überladungsauflösung beim Initialisieren eines Objekts einer solchen abgeleiteten Klasse einen der geerbten Konstruktoren auswählt, dann wird das Base -Subobjekt, von dem der Konstruktor geerbt wurde, mit dem geerbten Konstruktor initialisiert, und alle anderen Basen und Member von Derived werden wie durch den standardmäßig generierten Standardkonstruktor initialisiert (Standard-Member-Initialisierer werden verwendet, falls vorhanden, andernfalls findet Standardinitialisierung statt). Die gesamte Initialisierung wird als einzelner Funktionsaufruf behandelt: Die Initialisierung der Parameter des geerbten Konstruktors ist sequenced before der Initialisierung einer beliebigen Basis oder eines Members des abgeleiteten Objekts.

struct B1 { B1(int, ...) {} };
struct B2 { B2(double)   {} };
int get();
struct D1 : B1
{
    using B1::B1; // erbt B1(int, ...)
    int x;
    int y = get();
};
void test()
{
    D1 d(2, 3, 4); // OK: B1 wird durch Aufruf von B1(2, 3, 4) initialisiert,
                   // dann wird d.x standardinitialisiert (keine Initialisierung erfolgt),
                   // dann wird d.y durch Aufruf von get() initialisiert
    D1 e;          // Fehler: D1 hat keinen Standardkonstruktor
}
struct D2 : B2
{
    using B2::B2; // erbt B2(double)
    B1 b;
};
D2 f(1.0); // Fehler: B1 hat keinen Standardkonstruktor

struct W { W(int); };
struct X : virtual W
{
    using W::W; // erbt W(int)
    X() = delete;
};
struct Y : X
{
    using X::X;
};
struct Z : Y, virtual W
{
    using Y::Y;
};
Z z(0); // OK: Initialisierung von Y ruft nicht den Standardkonstruktor von X auf

Wenn das Base -Basisklassen-Subobjekt nicht als Teil des Derived -Objekts initialisiert werden soll (d.h. Base ist eine virtuelle Basisklasse von Derived , und das Derived -Objekt ist nicht das am meisten abgeleitete Objekt ), wird der Aufruf des geerbten Konstruktors, einschließlich der Auswertung aller Argumente, ausgelassen:

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" wird nicht aufgerufen, da das V-Subobjekt
         // nicht als Teil von B initialisiert wird
         // (das V-Subobjekt wird als Teil von C initialisiert,
         //  da "c" das am stärksten abgeleitete Objekt ist)
}

Wenn der Konstruktor von mehreren Basisklassen-Subobjekten des Typs Base geerbt wurde, ist das Programm fehlerhaft, ähnlich wie mehrfach geerbte nicht-statische Memberfunktionen:

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); // ungültig: Konstruktor von verschiedenen B-Basis-Subobjekten geerbt
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: Es gibt nur ein B-Subobjekt.
          // Dies initialisiert die virtuelle B-Basisklasse,
          //   welche die A-Basisklasse initialisiert
          // und initialisiert dann die V1- und V2-Basisklassen
          //   wie durch einen standardmäßigen Standardkonstruktor

Wie bei using-Deklarationen für andere nicht-statische Memberfunktionen, wenn ein geerbter Konstruktor mit der Signatur eines der Konstruktoren von Derived übereinstimmt, wird er von der in Derived gefundenen Version von der Suche ausgeschlossen. Wenn einer der geerbten Konstruktoren von Base zufällig die Signatur besitzt, die mit einem Kopier-/Verschiebekonstruktor von Derived übereinstimmt, verhindert dies nicht die implizite Generierung des Derived Kopier-/Verschiebekonstruktors (welcher dann die geerbte Version verdeckt, ähnlich wie bei 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) verdeckt sowohl B1::B1(int) als auch B2::B2(int)
};
D2 d2(0);    // ruft D2::D2(int) auf

Innerhalb einer templated class , wenn eine using-Deklaration auf einen dependent name verweist, wird dies als Benennung eines Konstruktors betrachtet, falls der nested-name-specifier einen terminalen Namen hat, der mit dem unqualified-id übereinstimmt.

template<class T>
struct A : T
{
    using T::T; // OK, erbt Konstruktoren von T
};
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // OK, erbt Konstruktoren von A<U>
    using T::A;    // erbt keine Konstruktoren von T
                   // selbst wenn T eine Spezialisierung von A<> sein könnte
};

Einführung von Scoped-Enumeratoren

Zusätzlich zu Membern eines anderen Namespace und Membern von Basisklassen kann eine using-Deklaration auch Enumeratoren von Enumerationen in Namespace-, Block- und Klassenbereiche einführen.

Eine using-Deklaration kann auch mit unscoped-Enumeratoren verwendet werden.

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

Die Semantik von geerbten Konstruktoren wurde nachträglich durch einen Defect Report gegen C++11 geändert. Zuvor verursachte eine deklarierende Konstruktorvererbung eine Reihe von synthetisierten Konstruktordeklarationen, die in die abgeleitete Klasse injiziert wurden, was redundante Argumentkopien/-verschiebungen verursachte, problematische Interaktionen mit einigen Formen von SFINAE hatte und in einigen Fällen auf wichtigen ABIs nicht implementierbar sein konnte. Ältere Compiler können weiterhin die vorherige Semantik implementieren.

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

Pack expansions in using-declarations ermöglichen es, eine Klasse zu bilden, die überladene Member variadischer Basen ohne Rekursion verfügbar macht:

template<typename... Ts>
struct Overloader : Ts...
{
    using Ts::operator()...; // exposes operator() from every base
};
template<typename... T>
Overloader(T...) -> Overloader<T...>; // C++17 deduction guide, not needed in C++20
int main()
{
    auto o = Overloader{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}