Using-declaration

複数のusing宣言子を持つusing宣言は、1つのusing宣言子を持つ対応する一連のusing宣言と等価である。

コンストラクタの継承

using-declaration が定義中のクラスの直接基底クラスのコンストラクタを参照する場合（例： using Base :: Base ; ）、その基底クラスの全てのコンストラクタ（メンバアクセスは無視）が派生クラスの初期化時にオーバーロード解決で可視化されます。

オーバーロード解決が継承されたコンストラクタを選択した場合、それが対応する基底クラスのオブジェクトを構築するために使用されたときにアクセス可能であれば、そのコンストラクタはアクセス可能です：それを導入したusing宣言のアクセシビリティは無視されます。

そのような派生クラスのオブジェクトを初期化する際にオーバーロード解決が継承されたコンストラクタのいずれかを選択した場合、コンストラクタが継承された Base サブオブジェクトは継承されたコンストラクタを使用して初期化され、 Derived の他のすべての基底クラスとメンバは、デフォルト化されたデフォルトコンストラクタによって初期化されたかのように初期化されます（デフォルトメンバ初期化子が提供されている場合はそれが使用され、それ以外の場合はデフォルト初期化が行われます）。初期化全体は単一の関数呼び出しとして扱われます：継承されたコンストラクタのパラメータの初期化は、派生オブジェクトの任意の基底クラスまたはメンバの初期化より 前にシーケンスされます 。

struct B1 { B1(int, ...) {} };
struct B2 { B2(double)   {} };
int get();
struct D1 : B1
{
    using B1::B1; // B1(int, ...) を継承
    int x;
    int y = get();
};
void test()
{
    D1 d(2, 3, 4); // OK: B1 は B1(2, 3, 4) の呼び出しで初期化され、
                   // 次に d.x はデフォルト初期化され（初期化は実行されない）、
                   // 次に d.y は get() の呼び出しで初期化される
    D1 e;          // エラー: D1 はデフォルトコンストラクタを持たない
}
struct D2 : B2
{
    using B2::B2; // B2(double) を継承
    B1 b;
};
D2 f(1.0); // エラー: B1 はデフォルトコンストラクタを持たない

struct W { W(int); };
struct X : virtual W
{
    using W::W; // W(int)を継承
    X() = delete;
};
struct Y : X
{
    using X::X;
};
struct Z : Y, virtual W
{
    using Y::Y;
};
Z z(0); // OK: Yの初期化はXのデフォルトコンストラクタを呼び出さない

Base 基底クラスの基底部分オブジェクトが Derived オブジェクトの一部として初期化されない場合（すなわち、 Base が Derived の 仮想基底クラス であり、かつ Derived オブジェクトが 最も派生したオブジェクト でない場合）、継承されたコンストラクタの呼び出し（引数の評価を含む）は省略されます：

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」は呼び出されない。なぜならVの部分オブジェクトは
         // Bの一部として初期化されないため
         // （Vの部分オブジェクトはCの一部として初期化される。
         //  なぜなら「c」が最も派生したオブジェクトであるため）
}

コンストラクタが型 Base の複数の基底クラスサブオブジェクトから継承された場合、多重継承された非静的メンバー関数と同様に、プログラムは不適格となります：

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); // 不適格: 異なる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: B部分オブジェクトは1つだけ存在する
          // これは仮想B基底クラスを初期化し、
          //   A基底クラスを初期化し、
          // その後V1とV2基底クラスを
          //   デフォルト化されたデフォルトコンストラクタによって初期化する

他の非静的メンバ関数に対するusing宣言と同様に、継承されたコンストラクタが Derived のコンストラクタのシグネチャと一致する場合、 Derived で見つかったバージョンによってルックアップから隠蔽されます。 Base の継承されたコンストラクタの1つが Derived のコピー/ムーブコンストラクタと一致するシグネチャを持つ場合でも、 Derived のコピー/ムーブコンストラクタの暗黙的な生成を妨げることはありません（その後、継承されたバージョンを隠蔽します。これは 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) は B1::B1(int) と B2::B2(int) の両方を隠蔽する
};
D2 d2(0);    // D2::D2(int) を呼び出す

テンプレート化された クラス内 では、using宣言が 依存名 を参照する場合、 修飾名指定子 の終端名が 非修飾ID と同じであるとき、コンストラクタを指定していると見なされます。

template<class T>
struct A : T
{
    using T::T; // OK、Tのコンストラクタを継承
};
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // OK、A<U>のコンストラクタを継承
    using T::A;    // Tのコンストラクタを継承しない
                   // たとえTがA<>の特殊化であっても
};

スコープ付き列挙子の導入

他の名前空間のメンバーや基底クラスのメンバーに加えて、using宣言は 列挙型 の列挙子を名前空間、ブロック、クラススコープに導入することもできます。

using宣言はスコープなし列挙子でも使用できます。

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

継承コンストラクタのセマンティクスは、 C++11に対する欠陥報告 によって遡及的に変更されました。以前は、継承コンストラクタ宣言によって派生クラスに合成されたコンストラクタ宣言のセットが注入され、冗長な引数のコピー/ムーブが発生し、一部のSFINAE形式との問題のある相互作用があり、主要なABIでは実装不可能な場合がありました。古いコンパイラは以前のセマンティクスを実装している場合があります。

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

パック展開 をusing宣言で使用することで、再帰なしで可変個基底クラスのオーバーロードされたメンバーを公開するクラスを形成できます：

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