선언을 사용합니다.
using 선언 이름을 소개 하는 선언적 영역으로는 using 선언을 표시 합니다.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
설명
다른 부분에서 선언 된 엔터티에 대 한 동의어 이름을 됩니다.이 개별 없이 사용 되는 특정 네임 스페이스에서 이름이 명시적 한정.이 대조적입니다의 using 허용 하는 지시어 모든 이름에서 네임 스페이스 한정자 없이 사용할 수 있습니다.참조 하십시오 지시문을 사용 하 여 에 대 한 자세한 내용은.
예제
A 선언을 사용 하 여 사용할 수 있습니다에서 클래스 정의입니다.
// 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_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_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 문 초 int i 에서 선언 하는 g() 함수입니다.using B::f 문을와 충돌 하지 않는 있는 f(char) 함수 이름으로 도입 된 때문에 기능 B::f 서로 다른 매개 변수 형식을 사용할.
지역 함수 선언이 함수 선언을 사용 하 여 도입 된 동일한 이름 및 형식을 가질 수 없습니다.예를 들면 다음과 같습니다.
// 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_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
};