선언 사용using declaration

선언에는 using using 선언이 표시 되는 선언적 영역에 대 한 이름이 도입 됩니다.The using declaration introduces a name into the declarative region in which the using declaration appears.

구문Syntax

using [typename] nested-name-specifier unqualified-id ;
using declarator-list ;

매개 변수Parameters

중첩 된 이름 지정자 범위 확인 연산자에 의해 종료 되는 네임 스페이스, 클래스 또는 열거형 이름 및 범위 확인 연산자 (::)의 시퀀스입니다.nested-name-specifier A sequence of namespace, class, or enumeration names and scope resolution operators (::), terminated by a scope resolution operator. 단일 범위 확인 연산자를 사용 하 여 전역 네임 스페이스의 이름을 도입할 수 있습니다.A single scope resolution operator may be used to introduce a name from the global namespace. 키워드는 typename 선택 사항이 며 기본 클래스에서 클래스 템플릿에 도입 될 때 종속 이름을 확인 하는 데 사용할 수 있습니다.The keyword typename is optional and may be used to resolve dependent names when introduced into a class template from a base class.

정규화 되지 않은 id 식별자, 오버 로드 된 연산자 이름, 사용자 정의 리터럴 연산자 또는 변환 함수 이름, 클래스 소멸자 이름 또는 템플릿 이름과 인수 목록 일 수 있는 정규화 되지 않은 id 식입니다.unqualified-id An unqualified id-expression, which may be an identifier, an overloaded operator name, a user-defined literal operator or conversion function name, a class destructor name, or a template name and argument list.

선언 자 목록 쉼표로 구분 된 [ typename ] 중첩 이름 지정자 의 정규화 되지 않은 id 선언 자입니다 .이 목록에는 선택적으로 줄임표가 있습니다.declarator-list A comma-separated list of [typename] nested-name-specifier unqualified-id declarators, followed optionally by an ellipsis.

설명Remarks

Using 선언은 다른 곳에서 선언 된 엔터티의 동의어로 정규화 되지 않은 이름을 도입 합니다.A using declaration introduces an unqualified name as a synonym for an entity declared elsewhere. 이를 통해 특정 네임 스페이스의 단일 이름이 표시 되는 선언 영역에서 명시적인 자격 없이 사용 될 수 있습니다.It allows a single name from a specific namespace to be used without explicit qualification in the declaration region in which it appears. 이는 네임 스페이스의 모든 이름을 한정자 없이 사용할 수 있도록 하는 using 지시문과는 대조적입니다.This is in contrast to the using directive, which allows all the names in a namespace to be used without qualification. using 키워드는 형식 별칭에도 사용 됩니다.The using keyword is also used for type aliases.

예: using 클래스 필드의 선언Example: using declaration in class field

Using 선언은 클래스 정의에서 사용할 수 있습니다.A using declaration can be used in a class definition.

// 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;    // B::f(char) is now visible as D::f(char)
   using B::g;    // B::g(char) is now visible as D::g(char)
   void f(int) {
      printf_s("In D::f()\n");
      f('c');     // Invokes B::f(char) instead of recursing
   }

   void g(int) {
      printf_s("In D::g()\n");
      g('c');     // Invokes B::g(char) instead of recursing
   }
};

int main() {
   D myD;
   myD.f(1);
   myD.g('a');
}
In D::f()
In B::f()
In B::g()

예: using 멤버를 선언 하는 선언Example: using declaration to declare a member

멤버를 선언 하는 데 사용 하는 경우 using 선언은 기본 클래스의 멤버를 참조 해야 합니다.When used to declare a member, a using declaration must refer to a member of a base class.

// 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');
}
In B::f()

예: using 명시적 한정자를 사용한 선언Example: using declaration with explicit qualification

Using 선언을 사용 하 여 선언 된 멤버는 명시적 한정자를 사용 하 여 참조할 수 있습니다.Members declared by using a using declaration can be referenced by using explicit qualification. ::접두사는 전역 네임 스페이스를 참조 합니다.The :: prefix refers to the global namespace.

// 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 is also visible as X::f
   using A::g;   // A's g is now visible as X::g
}

void h() {
   printf_s("In h\n");
   X::f();   // calls ::f
   X::g();   // calls A::g
}

int main() {
   h();
}
In h
In f
In A::g

예: using 선언 동의어 및 별칭Example: using declaration synonyms and aliases

Using 선언이 생성 되 면 선언에 의해 생성 된 동의어가 using 선언 지점에서 유효한 정의만 참조 합니다.When a using declaration is made, the synonym created by the declaration refers only to definitions that are valid at the point of the using declaration. Using 선언 후에 네임 스페이스에 추가 된 정의는 유효한 동의어가 아닙니다.Definitions added to a namespace after the using declaration are not valid synonyms.

선언에 의해 정의 되는 이름은 using 원래 이름에 대 한 별칭입니다.A name defined by a using declaration is an alias for its original name. 원래 선언의 형식, 링크 또는 다른 특성에는 영향을 주지 않습니다.It does not affect the type, linkage or other attributes of the original declaration.

// 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);
}

예: 로컬 선언 및 using 선언Example: Local declarations and using declarations

네임 스페이스의 함수와 관련 하 여 단일 이름에 대 한 로컬 선언 집합 및 선언 사용이 선언적 영역에 제공 되는 경우 모두 동일한 엔터티를 참조 하거나 모두 함수를 참조 해야 합니다.With respect to functions in namespaces, if a set of local declarations and using declarations for a single name are given in a declarative region, they must all refer to the same entity, or they must all refer to functions.

// 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() 합니다.In the example above, the using B::i statement causes a second int i to be declared in the g() function. using B::f f(char) 에서 제공 하는 함수 이름에 B::f 다른 매개 변수 형식이 있으므로 문이 함수와 충돌 하지 않습니다.The using B::f statement does not conflict with the f(char) function because the function names introduced by B::f have different parameter types.

예: 로컬 함수 선언 및 using 선언Example: Local function declarations and using declarations

로컬 함수 선언은 선언을 사용 하 여 도입 된 함수와 동일한 이름과 형식을 가질 수 없습니다.A local function declaration cannot have the same name and type as a function introduced by using declaration. 예를 들어:For example:

// 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 선언 및 상속Example: using declaration and inheritance

상속과 관련 하 여, using 선언으로 기본 클래스에서 파생 클래스 범위로 이름이 제공 되는 경우 파생 클래스의 멤버 함수는 기본 클래스에서 동일한 이름 및 인수 형식을 사용 하 여 가상 멤버 함수를 재정의 합니다.With respect to inheritance, when a using declaration introduces a name from a base class into a derived class scope, member functions in the derived class override virtual member functions with the same name and argument types in the base class.

// 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);
}
In D::f(int)
In B::f(char)
In B::g
In D::g(char)

예: using 선언 액세스 가능성Example: using declaration accessibility

Using 선언에서 언급 한 이름의 모든 인스턴스에 액세스할 수 있어야 합니다.All instances of a name mentioned in a using declaration must be accessible. 특히 파생 클래스에서 using 선언을 사용 하 여 기본 클래스의 멤버에 액세스 하는 경우 멤버 이름에 액세스할 수 있어야 합니다.In particular, if a derived class uses a using declaration to access a member of a base class, the member name must be accessible. 오버 로드 된 멤버 함수의 이름이 면 명명 된 모든 함수에 액세스할 수 있어야 합니다.If the name is that of an overloaded member function, then all functions named must be accessible.

멤버의 액세스 가능성에 대 한 자세한 내용은 멤버 Access Control를 참조 하세요.For more information on accessibility of members, see Member-Access Control.

// 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
};

참고 항목See also

네임스페이스Namespaces
키워드Keywords