使用声明
using 声明引入名称。 using 说明将出现的声明区域。
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
备注
该名称是在其他地方声明的实体的同义词。 它允许从给定命名空间的 单个 名称使用，而不需要 显式限定。 与 using 指令不同，这是，可以在命名空间中的 所有 名称使用，无需限定。 请参见 使用指令 有关更多信息。
示例
using 声明的可用于类定义。
// using_declaration1.cpp
#include <stdio.h>
class B {
public:
void f(char) {
printf_s("In B::f()\n");
}
void g(char) {
printf_s("In B::g()\n");
}
};
class D : B {
public:
using B::f;
using B::g;
void f(int) {
printf_s("In D::f()\n");
f('c');
}
void g(int) {
printf_s("In D::g()\n");
g('c');
}
};
int main() {
D myD;
myD.f(1);
myD.g('a');
}
当用于声明成员，的 using 声明一个必须引用基类的成员。
// using_declaration2.cpp
#include <stdio.h>
class B {
public:
void f(char) {
printf_s("In B::f()\n");
}
void g(char) {
printf_s("In B::g()\n");
}
};
class C {
public:
int g();
};
class D2 : public B {
public:
using B::f; // ok: B is a base of D2
// using C::g; // error: C isn't a base of D2
};
int main() {
D2 MyD2;
MyD2.f('a');
}
使用显式限定，成员声明与 using 声明可以引用。 :: 前缀引用全局命名空间。
// using_declaration3.cpp
#include <stdio.h>
void f() {
printf_s("In f\n");
}
namespace A {
void g() {
printf_s("In A::g\n");
}
}
namespace X {
using ::f; // global f
using A::g; // A's g
}
void h() {
printf_s("In h\n");
X::f(); // calls ::f
X::g(); // calls A::g
}
int main() {
h();
}
当使用声明中创建一个进行时，声明创建一个同义词只引用该使用的声明是有效的定义。 定义添加到命名空间中使用的声明之后无效同义词。
中定义的名称使用声明为其原始名称的别名。 它不影响类型、链接或原始声明的其他属性。
// post_declaration_namespace_additions.cpp
// compile with: /c
namespace A {
void f(int) {}
}
using A::f; // f is a synonym for A::f(int) only
namespace A {
void f(char) {}
}
void f() {
f('a'); // refers to A::f(int), even though A::f(char) exists
}
void b() {
using A::f; // refers to A::f(int) AND A::f(char)
f('a'); // calls A::f(char);
}
有关命名空间中的函数，因此，如果设置局部声明和使用说明用于某个唯一名称在一个描述性区域为，它们必须都引用同一个实体，也必须全部引用功能。
// functions_in_namespaces1.cpp
// C2874 expected
namespace B {
int i;
void f(int);
void f(double);
}
void g() {
int i;
using B::i; // error: i declared twice
void f(char);
using B::f; // ok: each f is a function
}
在上面的示例中， using B::i 语句在 g() 功能会导致一个 int i 声明。 ，因为 B::f 引入的函数名称具有不同的参数类型， using B::f 语句不冲突与 f(char) 功能。
本地函数声明不能与类型和函数同名中引入使用说明。 例如：
// functions_in_namespaces2.cpp
// C2668 expected
namespace B {
void f(int);
void f(double);
}
namespace C {
void f(int);
void f(double);
void f(char);
}
void h() {
using B::f; // introduces B::f(int) and B::f(double)
using C::f; // C::f(int), C::f(double), and C::f(char)
f('h'); // calls C::f(char)
f(1); // C2668 ambiguous: B::f(int) or C::f(int)?
void f(int); // C2883 conflicts with B::f(int) and C::f(int)
}
有关继承，那么，当使用声明中的引入从基类中的名称到派生类范围时，派生类中重写虚成员函数的成员函数具有相同名称和参数输入基类。
// using_declaration_inheritance1.cpp
#include <stdio.h>
struct B {
virtual void f(int) {
printf_s("In B::f(int)\n");
}
virtual void f(char) {
printf_s("In B::f(char)\n");
}
void g(int) {
printf_s("In B::g\n");
}
void h(int);
};
struct D : B {
using B::f;
void f(int) { // ok: D::f(int) overrides B::f(int)
printf_s("In D::f(int)\n");
}
using B::g;
void g(char) { // ok: there is no B::g(char)
printf_s("In D::g(char)\n");
}
using B::h;
void h(int) {} // Note: D::h(int) hides non-virtual B::h(int)
};
void f(D* pd) {
pd->f(1); // calls D::f(int)
pd->f('a'); // calls B::f(char)
pd->g(1); // calls B::g(int)
pd->g('a'); // calls D::g(char)
}
int main() {
D * myd = new D();
f(myd);
}
在中提到的名称的所有实例使用声明必须是可访问的。 特别是，因此，如果派生类使用 using 声明访问基类的成员，成员名称必须是可访问的。 如果名称是一个重载成员函数，则函数名的所有必须是可访问的。
请参见 成员访问控件，有关成员的可访问性的更多信息。
// using_declaration_inheritance2.cpp
// C2876 expected
class A {
private:
void f(char);
public:
void f(int);
protected:
void g();
};
class B : public A {
using A::f; // C2876: A::f(char) is inaccessible
public:
using A::g; // B::g is a public synonym for A::g
};