using 声明

来自cppreference.com
< cpp‎ | language

引入定义于别处的名称到此 using 声明所出现的声明性区域。

using typename(可选) nested-name-specifier unqualified-id ; (C++17 前)
using declarator-list ; (C++17 起)
nested-name-specifier - 名称与作用域解析运算符 :: 的序列,以作用域解析运算符结尾。单个 :: 指全局命名空间。
unqualified-id - id 表达式
typename - 在 using 声明从基类引入成员类型到类模板时,关键词 typename 可用于解析依赖名所必须处
declarator-list - 一或多个 typename(可选) nested-name-specifier unqualified-id 的声明器的逗号分隔列表。某些或全部声明器可后随省略号 ... 以指示包展开

目录

[编辑] 解释

using 声明可用于引入命名空间成员到另一命名空间与块作用域,或引入基类成员到派生类定义。

有多于一个 using 声明器的 using 声明等价于有一个 using 声明器的 using 声明的对应序列。

(C++17 起)

[编辑] 于命名空间与块作用域

using 声明引入另一命名空间的成员到当前命名空间或块作用域

#include <iostream>
#include <string>
using std::string;
int main()
{
    string str = "Example";
    using std::cout;
    cout << str;
}

细节见命名空间

[编辑] 于类定义

using 声明引入基类成员到派生类定义,例如暴露基类的受保护成员为派生类的公开成员。此情况下 nested-name-specifier 必须指名被定义的基类。若名称是基类的重载成员函数之名,则引入带该名称的所有基类成员函数。若派生类已有同名、参数列表及限定的成员,则派生类成员隐藏或覆写引入自基类的成员(不与之冲突)。

#include <iostream>
struct B {
    virtual void f(int) { std::cout << "B::f\n"; }
    void g(char)        { std::cout << "B::g\n"; }
    void h(int)         { std::cout << "B::h\n"; }
 protected:
    int m; // B::m 为受保护
    typedef int value_type;
};
 
struct D : B {
    using B::m; // D::m 为公开
    using B::value_type; // D::value_type 为公开
 
    using B::f;
    void f(int) { std::cout << "D::f\n"; } // D::f(int) 覆写 B::f(int)
    using B::g;
    void g(int) { std::cout << "D::g\n"; } // g(int) 与 g(char) 均作为 D 成员可见
    using B::h;
    void h(int) { std::cout << "D::h\n"; } // D::h(int) 隐藏 B::h(int)
};
 
int main()
{
    D d;
    B& b = d;
 
//    b.m = 2; // 错误, B::m 受保护
    d.m = 1; // 受保护的 B::m 可作为公开的 D::m 访问
    b.f(1); // 调用派生类 f()
    d.f(1); // 调用派生类 f()
    d.g(1); // 调用派生类 g(int)
    d.g('a'); // 调用基类 g(char)
    b.h(1); // 调用基类 h()
    d.h(1); // 调用派生类 h()
}

输出:

D::f
D::f
D::g
B::g
B::h
D::h

继承构造函数

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 通过调用 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 的默认构造函数

若从 B 类型的多基类子对象继承构造函数,则程序为病式,类似多继承的非静态成员函数:

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); };
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)
(C++11 起)

[编辑] 注意

唯有显式提及于 using 声明的名称被传送到声明性作用域:特别是, using 声明枚举类型名时,不传送枚举项。

using 声明不能指代命名空间、有作用域枚举项、基类析构函数或用于定义转换函数的成员模板特化。

using 声明不能指名成员模板特化(文法不容许模板 id ):

struct B { template<class T> void f(); };
struct D : B {
      using B::f;      // OK :指名模板
//    using B::f<int>; // 错误:指名模板特化
      void g() { f<int>(); }
};

using 声明亦无法用于将依赖成员模板的名称为模板名引入(不容许依赖名template 消歧义符):

template<class X> struct B { template<class T> void f(T); };
template<class Y> struct D : B<Y> {
//  using B<Y>::template f; // 错误:不允许消歧义符
  using B<Y>::f;            // 能编译,但 f 不是模板名
  void g() {
//    f<int>(0);            // 错误:已知 f 不是目标名,
                            // 故 < 不开始模板实参列表
      f(0);                 // OK
  }   
};

若 using 声明带基类赋值运算符到派生类,而其签名恰好匹配派生类的复制赋值或移动赋值运算符,则该运算符为派生类的隐式声明复制/移动赋值运算符所隐藏。相同的规则应用到继承恰好匹配派生类移动/复制构造函数的基类构造函数的 using 声明。 (C++11 起)

针对 C++11 的缺陷报告追加地更改了继承构造函数的语义。以前,继承构造函数的声明导致将一组合成的构造函数声明注入派生类,这导致冗余的参数复制/移动,与某些形式的 SFINAE 的交互有问题,而且某些情况下在主流 ABI 上无法实现。旧编译器可能仍然实现先前的语义。

旧的继承构造函数语义

using 声明指代被定义类的直接基类的构造函数(例如 using Base::Base; ),则按照下列规则继承该基类的构造函数:

1) 继承构造函数候选的集合由以下组成
a) 基类的所有非模板构造函数(在忽略省略号参数后,若它存在) (C++14 起)
b) 对于每个有默认参数或省略号参数的构造函数,所有构造函数签名由丢弃省略号者,及逐个忽略来自参数列表尾的默认参数者组成
c) 基类的所有构造函数模板(在忽略省略号参数后,若它存在) (C++14 起)
d) 对于每个有默认参数或省略号参数的构造函数模板,所有构造函数签名由丢弃省略号者,及逐个忽略来自参数列表尾的默认参数者组成
2) 所有继承构造函数,之非默认构造函数或复制/移动构造函数,而其签名不匹配用户定义于派生类之构造函数者,为派生类所隐式声明。不继承默认参数:
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) <- 继承的
};

继承的构造函数等价于有空函数体和由单个 nested-name-specifier 组成的成员初始化器列表的用户定义构造函数,它转发其所有参数到基类构造函数。

它与对应的基类构造函数有同样的访问。若用户定义构造函数会满足 constexpr 构造函数要求,则它为 constexpr 。若基类构造函数被删除,或若默认化的默认构造会被删除,则它被删除(除了不计构造函数要被继承的基类的构造)。继承的构造函数不能显式实例化或显式特化。

若 using 声明(从二个有别基类)继承有相同签名的构造函数,则程序为病式。

(C++11 起)

using 声明中的包展开令组成的类暴露变长基类的重载成员,而无需递归:

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;} };
}
(C++17 起)

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR 应用于 出版时的行为 正确行为
P0136R1 C++11 继承构造函数声明会将额外的构造函数注入派生类 导致名称查找能找到基类构造函数