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 が braced-init-list である場合、 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[]> を返す