Class template argument deduction (CTAD) (since C++17)

• 상수 템플릿 매개변수의 타입:

template<class T>
struct X
{
    constexpr X(T) {}
};
template<X x>
struct Y {};
Y<0> y; // OK, Y<X<int>(0)>

• F i 의 연관된 제약 조건 은 C 의 연관된 제약 조건과 C i 의 연관된 제약 조건의 논리곱입니다.

• 추가적으로, 다음 조건을 모두 만족하는 경우

• C 가 정의되어 있고 모든 종속 기저 클래스에 가상 함수나 가상 기저 클래스가 없다고 가정할 때 집합체 타입 의 요구사항을 충족하며,
• C 에 대한 사용자 정의 deduction guide가 존재하지 않고,
• 변수가 비어 있지 않은 초기화자 목록 arg1, arg2, ..., argn ( 지정 초기화자 사용 가능)으로 초기화되는 경우,

집합체 deduction 후보가 추가될 수 있습니다. 집합체 deduction 후보의 매개변수 목록은 집합체 요소 타입들로부터 다음과 같이 생성됩니다:

• e i 를 arg i 로 초기화되는 (재귀적일 수 있는) 집합체 요소 라고 정의합니다. 단,

• 다음 중 하나에 해당하는 집합체 요소에 대해서는 brace elision 을 고려하지 않습니다:

• 종속 비배열 타입,
• 값 종속 경계를 가진 배열 타입, 또는
• 종속 배열 요소 타입을 가지며 arg i 가 문자열 리터럴 인 배열 타입

• C (또는 그 자체가 집합체인 요소)가 pack expansion 인 기저 클래스를 가지는 경우:

• pack expansion이 후행 집합체 요소인 경우, 초기화자 목록의 모든 나머지 요소와 일치하는 것으로 간주합니다;
• 그렇지 않으면 pack은 비어 있는 것으로 간주합니다.

• 이러한 e i 가 존재하지 않으면 집합체 deduction 후보를 추가하지 않습니다.
• 그렇지 않으면, 집합체 deduction 후보의 매개변수 목록 T 1 , T 2 , ..., T n 을 다음과 같이 결정합니다:

• e i 가 배열이고 arg i 가 braced-init-list 인 경우, T i 는 e i 의 선언된 타입에 대한 rvalue 참조입니다.
• e i 가 배열이고 arg i 가 문자열 리터럴 인 경우, T i 는 e i 의 const 한정 선언된 타입에 대한 lvalue 참조입니다.
• 그렇지 않으면, T i 는 e i 의 선언된 타입입니다.
• pack이 비후행 집합체 요소여서 건너뛴 경우, 원래 집합체 요소 위치에 P j ... 형태의 추가 매개변수 pack을 삽입합니다. (일반적으로 이는 deduction 실패를 유발합니다.)
• pack이 후행 집합체 요소인 경우, 이에 해당하는 후행 매개변수 시퀀스는 T n ... 형태의 단일 매개변수로 대체됩니다.

집합체 deduction 후보는 위에서 유도된 가상 생성자 C(T 1 , T 2 , ..., T n ) 로부터 파생된 가상 함수 템플릿입니다.

집합체 deduction 후보에 대한 템플릿 인자 deduction 중에는, 후행 매개변수 pack의 요소 수는 다른 방식으로 deduction되지 않는 경우에만 남은 함수 인자의 수로부터 deduction됩니다.

template<class T>
struct A
{
    T t;
    struct
    {
        long a, b;
    } u;
};
A a{1, 2, 3};
// aggregate deduction candidate:
//   template<class T>
//   A<T> F(T, long, long);
template<class... Args>
struct B : std::tuple<Args...>, Args... {};
B b{std::tuple<std::any, std::string>{}, std::any{}};
// aggregate deduction candidate:
//   template<class... Args>
//   B<Args...> F(std::tuple<Args...>, Args...);
// type of b is deduced as B<std::any, std::string>

사용자 정의 추론 가이드의 매개변수는 플레이스홀더 타입을 가질 수 없습니다: 축약 함수 템플릿 구문은 허용되지 않습니다.

별칭 템플릿에 대한 추론

함수 스타일 캐스트나 변수 선언에서 인수 목록 없이 별칭 템플릿 A 의 이름을 타입 지정자로 사용할 때, A 가 B<ArgList> 의 별칭으로 정의되고, B 의 범위가 비의존적이며, B 가 클래스 템플릿이나 유사하게 정의된 별칭 템플릿인 경우, 추론은 클래스 템플릿과 같은 방식으로 진행되지만, 가이드는 다음과 같이 B 의 가이드에서 생성됩니다:

• B 의 각 가이드 f 에 대해, 템플릿 인수 추론 을 사용하여 f 의 반환 타입 템플릿 인수를 B<ArgList> 에서 추론합니다. 단, 일부 인수가 추론되지 않아도 추론이 실패하지 않습니다. 다른 이유로 추론이 실패하면 추론된 템플릿 인수의 빈 집합으로 진행합니다.
• 위 추론의 결과를 f 에 대입합니다. 대입이 실패하면 가이드가 생성되지 않습니다. 그렇지 않으면 대입 결과를 g 로 표시하고, 가이드 f' 가 다음과 같이 형성됩니다:

• f' 의 매개변수 타입과 반환 타입은 g 와 동일합니다.
• f 가 템플릿인 경우, f' 는 템플릿 매개변수 목록이 위 추론에 나타나거나 (재귀적으로) 기본 템플릿 인수에 나타나는 A 의 모든 템플릿 매개변수 (기본 템플릿 인수 포함)와 추론되지 않은 f 의 템플릿 매개변수 (기본 템플릿 인수 포함)로 구성된 함수 템플릿입니다. 그렇지 않은 경우 ( f 가 템플릿이 아닌 경우) f' 는 함수입니다.
• f' 의 관련 제약 조건 은 g 의 관련 제약 조건과 A 의 인수가 결과 타입에서 추론 가능한 경우에만 만족되는 제약 조건의 결합입니다.

template<class T>
class unique_ptr
{
    /* ... */
};
template<class T>
class unique_ptr<T[]>
{
    /* ... */
};
template<class T>
unique_ptr(T*) -> unique_ptr<T>;   // #1
template<class T>
unique_ptr(T*) -> unique_ptr<T[]>; // #2
template<class T>
concept NonArray = !std::is_array_v<T>;
template<NonArray A>
using unique_ptr_nonarray = unique_ptr<A>;
template<class A>
using unique_ptr_array = unique_ptr<A[]>;
// generated guide for unique_ptr_nonarray:
// from #1 (deduction of unique_ptr<T> from unique_ptr<A> yields T = A):
// template<class A>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<A>>)
// auto F(A*) -> unique_ptr<A>;
// from #2 (deduction of unique_ptr<T[]> from unique_ptr<A> yields nothing):
// template<class T>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<T[]>>)
// auto F(T*) -> unique_ptr<T[]>;
// where argument_of_unique_ptr_nonarray_is_deducible_from can be defined as
// template<class>
// class AA;
// template<NonArray A>
// class AA<unique_ptr_nonarray<A>> {};
// template<class T>
// concept argument_of_unique_ptr_nonarray_is_deducible_from =
//     requires { sizeof(AA<T>); };
// generated guide for unique_ptr_array:
// from #1 (deduction of unique_ptr<T> from unique_ptr<A[]> yields T = A[]):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A(*)[]) -> unique_ptr<A[]>;
// from #2 (deduction of unique_ptr<T[]> from unique_ptr<A[]> yields T = A):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A*) -> unique_ptr<A[]>;
// where argument_of_unique_ptr_array_is_deducible_from can be defined as
// template<class>
// class BB;
// template<class A>
// class BB<unique_ptr_array<A>> {};
// template<class T>
// concept argument_of_unique_ptr_array_is_deducible_from =
//     requires { sizeof(BB<T>); };
// Use:
unique_ptr_nonarray p(new int); // deduced to unique_ptr<int>
// deduction guide generated from #1 returns unique_ptr<int>
// deduction guide generated from #2 returns unique_ptr<int[]>, which is ignored because
//   argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<int[]>> is unsatisfied
unique_ptr_array q(new int[42]); // deduced to unique_ptr<int[]>
// deduction guide generated from #1 fails (cannot deduce A in A(*)[] from new int[42])
// deduction guide generated from #2 returns unique_ptr<int[]>