using 声明
将别处定义的名字引入到此 using 声明所出现的声明区中。有关其他相关声明，参见 using enum 和 (C++20 起)using namespace。
using typename(可选) 嵌套名说明符 无限定标识 ;
|
(C++17 前) | ||||||||
using 声明符列表 ;
|
(C++17 起) | ||||||||
typename
|
- | 在 using 声明从基类向类模板中引入成员类型时，可能需要用关键词 typename 解决待决名
|
| 嵌套名说明符 | - | 名字与作用域解析运算符 :: 的序列，以作用域解析运算符结尾。单个 :: 指代全局命名空间。
|
| 无限定标识 | - | 标识表达式 |
| 声明符列表 | - | 一个或多个形式为 typename(可选) 嵌套名说明符 无限定标识 的声明符的逗号分隔列表。某些或所有声明符都可以后随省略号 ... 以指示包展开
|
解释
using 声明可以用来将命名空间成员引入到另一命名空间与块作用域，或将基类成员引入到派生类定义中，或将枚举项引入命名空间、块或类作用域中(C++20 起)。
|
包含多于一个 using 声明符的 using 声明等价于一系列相应数量的包含单个 using 声明符的 using 声明。 |
(C++17 起) |
在命名空间和块作用域中
using 声明将另一命名空间的成员引入到当前命名空间或块作用域中。
#include <iostream>
#include <string>
using std::string;
int main()
{
string str = "举例";
using std::cout;
cout << str;
}
细节见命名空间。
在类定义中
using 声明可以将基类成员引入到派生类的定义中，例如将基类的受保护成员暴露为派生类的公开成员。此时 嵌套名说明符 必须指名所定义的类的某个基类。如果这个名字是该基类的某个重载的成员函数的名字，那么具有该名字的所有基类成员函数均被引入。如果派生类已包含具有相同名字、形参列表和限定的成员，那么派生类成员隐藏或覆盖从基类引入的成员（不与之冲突）。
#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) override { 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) 均可见
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()
std::cout << "----------\n";
d.g(1); // 调用派生类的 g(int)
d.g('a'); // 调用基类的 g(char)，它因 using B::g; 而暴露
std::cout << "----------\n";
b.h(1); // 调用基类的 h()
d.h(1); // 调用派生类的 h()
}
输出：
D::f
D::f
----------
D::g
B::g
----------
B::h
D::h
继承构造函数如果 using 声明指代了正在定义的类的某个直接基类的构造函数（例如 如果重载决议选择了继承的构造函数，那么如果它被用于构造相应基类的对象时可访问，它也是可访问的：引入它的 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 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; // 因为 V 子对象不会作为 B 的一部分被初始化，所以不会调用 “bar”
// （V 子对象会作为 C 的一部分被初始化，这是因为 “c” 才是最终派生对象）
}
如果构造函数从 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 声明相同，如果继承的构造函数的签名与 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 声明指代待决名，而 嵌套名说明符 拥有与该 无限定标识 相同的终止名，那么认为它指名构造函数。 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<> 的特化
};
|
(C++11 起) |
引入有作用域枚举项除了另一命名空间的成员和基类的成员，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，尽管不需要
|
(C++20 起) |
注解
只有在 using 声明中明确提及的名字才会被传送到声明区中：特别是，using 声明枚举类型名时不会传送它的枚举项。
using 声明不能指代命名空间，有作用域枚举项(C++20 前)，基类的析构函数，或用户定义转换函数的成员模板的特化。
using 声明不能指名成员模板的特化（语法不容许模板标识）：
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 上无法实现。旧编译器可能仍然实现先前的语义。
|
(C++11 起) |
|
在 using 声明中使用包展开可以替代递归来组成暴露变长基类的重载成员的类： template<typename... Ts>
struct Overloader : Ts...
{
using Ts::operator()...; // 从每个基类暴露 operator()
};
template<typename... T>
Overloader(T...) -> Overloader<T...>; // C++17 推导指引，C++20 起不再需要
int main()
{
auto o = Overloader{ [] (auto const& a) {std::cout << a;},
[] (float f) {std::cout << std::setprecision(3) << f;} };
}
|
(C++17 起) |
| 功能特性测试宏 | 值 | 标准 | 功能特性 |
|---|---|---|---|
__cpp_inheriting_constructors |
200802L |
(C++11) | 继承构造函数 |
201511L |
(C++17) (DR11) |
重新措辞继承构造函数 | |
__cpp_variadic_using |
201611L |
(C++17) | using 声明中的包展开
|
关键词
缺陷报告
下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。
| 缺陷报告 | 应用于 | 出版时的行为 | 正确行为 |
|---|---|---|---|
| CWG 258 | C++98 | 派生类的非 const 成员函数可以覆盖和/或隐藏它的基类的 const 成员函数 | 覆盖和隐藏也要求 cv 限定性一致 |
| CWG 1738 | C++11 | 不明确是否可以显式实例化或显式特化继承的构造函数模板 | 已禁止 |
| CWG 2504 | C++11 | 从虚基类继承构造函数的行为不明确 | 使之明确 |
| P0136R1 | C++11 | 继承构造函数声明会将额外的构造函数注入派生类 | 导致名字查找能找到基类构造函数 |
- 引用
引用
- C++23 标准（ISO/IEC 14882:2024）：
- 9.9 The
usingdeclaration [namespace.udecl]
- 9.9 The
- C++20 标准（ISO/IEC 14882:2020）：
- 9.9 The
usingdeclaration [namespace.udecl]
- 9.9 The
- C++17 标准（ISO/IEC 14882:2017）：
- 10.3.3 The
usingdeclaration [namespace.udecl]
- 10.3.3 The
- C++14 标准（ISO/IEC 14882:2014）：
- 7.3.3 The
usingdeclaration [namespace.udecl]
- 7.3.3 The
- C++11 标准（ISO/IEC 14882:2011）：
- 7.3.3 The
usingdeclaration [namespace.udecl]
- 7.3.3 The
- C++03 标准（ISO/IEC 14882:2003）：
- 7.3.3 The
usingdeclaration [namespace.udecl]
- 7.3.3 The
- C++98 标准（ISO/IEC 14882:1998）：
- 7.3.3 The
usingdeclaration [namespace.udecl]
- 7.3.3 The