Using-declaration

둘 이상의 using-선언자를 가진 using-선언은 하나의 using-선언자를 가진 해당 using-선언 시퀀스와 동등합니다.

생성자 상속

만약 using-declaration 이 정의 중인 클래스의 직접 기반 클래스 생성자를 참조하는 경우(예: using Base :: Base ; ), 해당 기반 클래스의 모든 생성자들(멤버 접근 제어는 무시)은 파생 클래스를 초기화할 때 오버로드 해결을 위해 visible 상태가 됩니다.

오버로드 해결이 상속된 생성자를 선택하면, 해당하는 기본 클래스의 객체를 생성하는 데 사용될 때 접근 가능한 경우 접근 가능합니다: 이를 도입한 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의 기본 생성자를 호출하지 않음

만약 Base 기본 클래스 하위 객체가 Derived 객체의 일부로 초기화되지 않는 경우 (즉, Base 가 가상 기본 클래스 이고 Derived 객체가 최종 파생 객체 가 아닌 경우), 상속된 생성자의 호출(인수 평가 포함)은 생략됩니다:

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()) {} // 정상
};
struct C : B {};
void foo()
{
    C c; // "bar"가 호출되지 않음. V 서브오브젝트가
         // B의 일부로 초기화되지 않기 때문
         // (V 서브오브젝트는 C의 일부로 초기화됨.
         //  "c"가 최종 파생 객체이기 때문)
}

생성자가 Base 타입의 여러 기본 클래스 하위 객체로부터 상속된 경우, 다중 상속된 비정적 멤버 함수와 유사하게 프로그램의 형식이 올바르지 않습니다:

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); // 올바른 형식: B 하위 객체가 하나만 존재합니다.
          // 이는 가상 B 기본 클래스를 초기화하며,
          //   A 기본 클래스를 초기화하고
          // 그런 다음 V1 및 V2 기본 클래스를
          //   기본값 생성자처럼 초기화합니다

다른 비정적 멤버 함수에 대한 using 선언과 마찬가지로, 상속된 생성자가 Derived 의 생성자 중 하나와 시그니처가 일치하면, Derived 에서 찾은 버전에 의해 lookup에서 숨겨집니다. 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)를 호출합니다

템플릿 클래스 내에서, 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<>의 특수화일지라도
};

범위 지정 열거자 도입

다른 네임스페이스의 멤버와 기본 클래스의 멤버 외에도, 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, though needless

상속 생성자의 의미론(semantics)은 C++11에 대한 결함 보고서 에 의해 소급되어 변경되었습니다. 이전에는 상속 생성자 선언이 파생 클래스에 합성된 생성자 선언 집합을 주입하도록 했으며, 이는 중복된 인자 복사/이동을 초래하고, 일부 형태의 SFINAE와 문제있는 상호작용을 일으키며, 일부 경우 주요 ABI에서 구현 불가능할 수 있었습니다. 이전 컴파일러들은 여전히 이전 의미론을 구현할 수 있습니다.

struct B1
{
    B1(int);
};
struct D1 : B1
{
    using B1::B1;
    // The set of candidate inherited constructors is 
    // 1. B1(const B1&)
    // 2. B1(B1&&)
    // 3. B1(int)
    // D1 has the following constructors:
    // 1. D1() = delete
    // 2. D1(const D1&) 
    // 3. D1(D1&&)
    // 4. D1(int) <- inherited
};
struct B2
{
    B2(int = 13, int = 42);
};
struct D2 : B2
{
    using B2::B2;
    // The set of candidate inherited constructors is
    // 1. B2(const B2&)
    // 2. B2(B2&&)
    // 3. B2(int = 13, int = 42)
    // 4. B2(int = 13)
    // 5. B2()
    // D2 has the following constructors:
    // 1. D2()
    // 2. D2(const D2&)
    // 3. D2(D2&&)
    // 4. D2(int, int) <- inherited
    // 5. D2(int) <- inherited
};

Pack expansions in using-declarations make it possible to form a class that exposes overloaded members of variadic bases without recursion:

template<typename... Ts>
struct Overloader : Ts...
{
    using Ts::operator()...; // exposes operator() from every base
};
template<typename... T>
Overloader(T...) -> Overloader<T...>; // C++17 deduction guide, not needed in C++20
int main()
{
    auto o = Overloader{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}