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 に対するユーザー定義の推論ガイドが存在しない場合、および
• 変数が空でない初期化子リスト arg1, arg2, ..., argn （ 指示付き初期化子 を使用可能）から初期化される場合、

集成体推論候補が追加される可能性があります。集成体推論候補のパラメータリストは、集成体要素の型から以下のように生成されます：

• e i を（再帰的である可能性のある） 集成体要素 とし、 arg i から初期化されるものとします。ただし：

• 以下のいずれかの条件を満たす集成体要素については 波括弧省略 を考慮しません：

• 依存型 の非配列型、
• 値依存 の境界を持つ配列型、または
• 依存する配列要素型を持つ配列型で、 arg i が 文字列リテラル である場合

• C （またはそれ自体が集成体であるその要素）が パック展開 である基底クラスを持つ場合：

• パック展開が末尾の集成体要素である場合、初期化子リストの残りの全要素に一致すると見なされます；
• それ以外の場合、パックは空であると見なされます。

• そのような e i が存在しない場合、集成体推論候補は追加されません。
• それ以外の場合、集成体推論候補のパラメータリスト T 1 , T 2 , ..., T n を以下のように決定します：

• e i が配列で arg i が 波括弧初期化リスト の場合、 T i は e i の宣言された型への右辺値参照です。
• e i が配列で arg i が 文字列リテラル の場合、 T i は e i の宣言された型へのconst修飾左辺値参照です。
• それ以外の場合、 T i は e i の宣言された型です。
• 非末尾の集成体要素であるためにパックがスキップされた場合、元の集成体要素の位置に P j ... の形式の追加パラメータパックが挿入されます（これにより一般に推論は失敗します）。
• パックが末尾の集成体要素である場合、それに対応する末尾のパラメータシーケンスは T n ... の形式の単一パラメータに置き換えられます。

集成体推論候補は、仮想的なコンストラクタ C(T 1 , T 2 , ..., T n ) から上記のように導出された架空の関数テンプレートです。

集成体推論候補に対するテンプレート引数推論中、末尾のパラメータパックの要素数は、他の方法で推論されない場合にのみ、残りの関数引数の数から推論されます。

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[]>;
// 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 から生成された推論ガイドは失敗 (new int[42] から A(*)[] の A を推論できない)
// #2 から生成された推論ガイドは unique_ptr<int[]> を返す