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 определен и удовлетворяет требованиям агрегатного типа с предположением, что любая зависимая базовый класс не имеет виртуальных функций или виртуальных базовых классов,
• нет пользовательских deduction guides для C , и
• переменная инициализируется из непустого списка инициализаторов arg1, arg2, ..., argn (которые могут использовать designated initializer ),

может быть добавлен агрегатный кандидат вывода. Список параметров агрегатного кандидата вывода формируется из типов элементов агрегата следующим образом:

• Пусть e i будет (возможно рекурсивным) агрегатным элементом , который будет инициализирован из arg i , где

• brace elision не рассматривается для любого агрегатного элемента, который имеет

• зависимый не-массивный тип,
• массивный тип с value-dependent границей, или
• массивный тип с зависимым типом элемента массива и arg i является string literal

• если C (или его элемент, который сам является агрегатом) имеет базовый класс, который является pack expansion :

• если pack expansion является завершающим агрегатным элементом, он считается соответствующим всем оставшимся элементам списка инициализации;
• иначе, pack считается пустым.

• Если такого e i не существует, агрегатный кандидат вывода не добавляется.
• Иначе, определяется список параметров T 1 , T 2 , ..., T n агрегатного кандидата вывода следующим образом:

• Если e i является массивом и arg i является braced-init-list , T i является rvalue ссылкой на объявленный тип e i .
• Если e i является массивом и arg i является string literal , T i является lvalue ссылкой на const-квалифицированный объявленный тип e i .
• Иначе, T i является объявленным типом e i .
• Если pack был пропущен, потому что он является незавершающим агрегатным элементом, дополнительный parameter pack вида P j ... вставляется в его исходную позицию агрегатного элемента. (Это, как правило, приведет к неудаче вывода.)
• Если pack является завершающим агрегатным элементом, завершающая последовательность параметров, соответствующая ему, заменяется единственным параметром вида T n ... .

Агрегатный кандидат вывода является вымышленным шаблоном функции, полученным как описано выше из гипотетического конструктора C(T 1 , T 2 , ..., T n ) .

Во время вывода аргументов шаблона для агрегатного кандидата вывода количество элементов в завершающем parameter pack выводится только из количества оставшихся аргументов функции, если оно не выведено иным образом.

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 , следующим образом:

• Для каждой направляющей f из B выведите аргументы шаблона возвращаемого типа 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[]>;
// сгенерированная направляющая для unique_ptr_nonarray:
// из #1 (вывод unique_ptr<T> из unique_ptr<A> дает T = A):
// template<class A>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<A>>)
// auto F(A*) -> unique_ptr<A>;
// из #2 (вывод unique_ptr<T[]> из unique_ptr<A> ничего не дает):
// template<class T>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<T[]>>)
// auto F(T*) -> unique_ptr<T[]>;
// где argument_of_unique_ptr_nonarray_is_deducible_from может быть определен как
// 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>); };
// сгенерированная направляющая для unique_ptr_array:
// из #1 (вывод unique_ptr<T> из unique_ptr<A[]> дает T = A[]):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A(*)[]) -> unique_ptr<A[]>;
// из #2 (вывод unique_ptr<T[]> из unique_ptr<A[]> дает T = A):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A*) -> unique_ptr<A[]>;
// где argument_of_unique_ptr_array_is_deducible_from может быть определен как
// 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>); };
// Использование:
unique_ptr_nonarray p(new int); // выведено в unique_ptr<int>
// направляющая вывода, сгенерированная из #1, возвращает unique_ptr<int>
// направляющая вывода, сгенерированная из #2, возвращает unique_ptr<int[]>, которая игнорируется, потому что
//   argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<int[]>> не выполняется
unique_ptr_array q(new int[42]); // выведено в unique_ptr<int[]>
// направляющая вывода, сгенерированная из #1, завершается неудачей (не может вывести A в A(*)[] из new int[42])
// направляющая вывода, сгенерированная из #2, возвращает unique_ptr<int[]>