using 宣言

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 のデフォルトコンストラクタを呼びません。

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); // ill-formed、コンストラクタが 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 の部分オブジェクトはひとつだけです。
          // これは仮想基底クラス B を初期化し
          // (それによって基底クラス A が初期化されます)、
          // それから基底クラス V1 および V2 を、デフォルト化された
          // デフォルトコンストラクタで行われたかのように初期化します。

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) を呼びます。

template <typename... Ts>
struct Overloader : Ts... {
    using Ts::operator()...; // すべての基底から operator() を露出させます。
};
 
template <typename... T>
Overloader(T...) -> Overloader<T...>; // C++17 の推定ガイド。
 
int main() {
    auto o = Overloader{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}