Using-declaration

具有多个 using 声明符的 using 声明等价于对应的单 using 声明符序列的 using 声明。

继承构造函数

若 using 声明 引用的是正在定义的类的直接基类的构造函数（例如 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(2, 3, 4) 初始化 B1，
                   // 然后 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 子对象。
          // 这会初始化虚基类 B，
          //   它初始化基类 A
          // 然后初始化基类 V1 和 V2
          //   如同通过默认的默认构造函数

与任何其他非静态成员函数的 using 声明一样，若继承的构造函数与 Derived 的某个构造函数签名匹配，则它会被 Derived 中找到的版本隐藏而无法通过查找找到。若 Base 的某个继承构造函数恰好与 Derived 的复制/移动构造函数签名匹配，它不会阻止隐式生成 Derived 的复制/移动构造函数（然后该生成版本会隐藏继承的版本，类似于 using operator= ）。

struct B1 { B1(int); }<span class="

引入作用域枚举项

除了其他命名空间的成员和基类的成员之外，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;
    // 候选继承构造函数集合为：
    // 1. B1(const B1&)
    // 2. B1(B1&&)
    // 3. B1(int)
    // D1 具有以下构造函数：
    // 1. D1() = delete
    // 2. D1(const D1&) 
    // 3. D1(D1&&)
    // 4. D1(int) <- 继承
};
struct B2
{
    B2(int = 13, int = 42);
};
struct D2 : B2
{
    using B2::B2;
    // 候选继承构造函数集合为：
    // 1. B2(const B2&)
    // 2. B2(B2&&)
    // 3. B2(int = 13, int = 42)
    // 4. B2(int = 13)
    // 5. B2()
    // D2 具有以下构造函数：
    // 1. D2()
    // 2. D2(const D2&)
    // 3. D2(D2&&)
    // 4. D2(int, int) <- 继承
    // 5. D2(int) <- 继承
};

包展开 在 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;} };
}