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

• der Typ eines konstanten Template-Parameters :

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

• Die assoziierten Constraints von F i sind die Konjunktion der assoziierten Constraints von C und der assoziierten Constraints von C i .

• Zusätzlich, falls

• C definiert ist und die Anforderungen eines Aggregattyps erfüllt unter der Annahme, dass jede abhängige Basisklasse keine virtuellen Funktionen oder virtuellen Basisklassen hat,
• keine benutzerdefinierten Deduktionsführer für C existieren, und
• die Variable aus einer nicht-leeren Liste von Initialisierern arg1, arg2, ..., argn initialisiert wird (die Designated Initializer verwenden können),

kann ein Aggregat-Deduktionskandidat hinzugefügt werden. Die Parameterliste des Aggregat-Deduktionskandidaten wird aus den Aggregat-Elementtypen wie folgt erzeugt:

• Sei e i das (möglicherweise rekursive) Aggregat-Element , das von arg i initialisiert werden würde, wobei

• Brace Elision für kein Aggregat-Element berücksichtigt wird, das

• einen abhängigen Nicht-Array-Typ,
• einen Array-Typ mit einer wertabhängigen Grenze, oder
• einen Array-Typ mit einem abhängigen Array-Elementtyp und arg i ein String-Literal ist

• falls C (oder sein Element, das selbst ein Aggregat ist) eine Basis hat, die eine Pack-Erweiterung ist:

• wenn die Pack-Erweiterung ein nachfolgendes Aggregat-Element ist, wird angenommen, dass sie alle verbleibenden Elemente der Initialisiererliste abdeckt;
• andernfalls wird das Pack als leer betrachtet.

• Falls kein solches e i existiert, wird der Aggregat-Deduktionskandidat nicht hinzugefügt.
• Andernfalls wird die Parameterliste T 1 , T 2 , ..., T n des Aggregat-Deduktionskandidaten wie folgt bestimmt:

• Wenn e i ein Array ist und arg i ein Braced-Init-List  ist, T i ist ein Rvalue-Referenz auf den deklarierten Typ von e i .
• Wenn e i ein Array ist und arg i ein String-Literal ist, T i ist eine Lvalue-Referenz auf den const-qualifizierten deklarierten Typ von e i .
• Andernfalls ist T i der deklarierte Typ von e i .
• Falls ein Pack übersprungen wurde, weil es ein nicht-nachfolgendes Aggregat-Element ist, wird ein zusätzliches Parameter-Pack der Form P j ... an seiner ursprünglichen Aggregat-Element-Position eingefügt. (Dies führt im Allgemeinen zu einem Fehlschlagen der Deduktion.)
• Falls ein Pack ein nachfolgendes Aggregat-Element ist, wird die nachfolgende Parameterfolge, die ihm entspricht, durch einen einzelnen Parameter der Form T n ... ersetzt.

Der Aggregat-Deduktionskandidat ist eine fiktive Funktionsvorlage, die wie oben von einem hypothetischen Konstruktor C(T 1 , T 2 , ..., T n ) abgeleitet wird.

Während der Template-Argument-Deduktion für den Aggregat-Deduktionskandidaten wird die Anzahl der Elemente in einem nachfolgenden Parameter-Pack nur aus der Anzahl der verbleibenden Funktionsargumente deduziert, falls sie nicht anderweitig deduziert wird.

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>

Die Parameter von benutzerdefinierten Deduktionsanleitungen können keine Platzhaltertypen haben: Die Abbreviated Function Template -Syntax ist nicht zulässig.

Deduktion für Alias-Templates

Wenn ein Funktionsstil-Cast oder eine Variablendeklaration den Namen eines Alias-Templates A ohne Argumentliste als Typspezifizierer verwendet, wobei A als Alias von B<ArgList> definiert ist, der Gültigkeitsbereich von B nicht-abhängig ist und B entweder ein Klassentemplate oder ein ähnlich definiertes Alias-Template ist, erfolgt die Deduktion auf dieselbe Weise wie für Klassentemplates, außer dass die Guides stattdessen aus den Guides von B generiert werden, wie folgt:

• Für jeden Guide f von B , deduziere die Template-Argumente des Rückgabetyps von f aus B<ArgList> unter Verwendung von Template-Argument-Deduktion , außer dass die Deduktion nicht fehlschlägt, wenn einige Argumente nicht deduziert werden. Wenn die Deduktion aus einem anderen Grund fehlschlägt, fahre mit einer leeren Menge deduzierter Template-Argumente fort.
• Substituiere das Ergebnis der obigen Deduktion in f ; wenn die Substitution fehlschlägt, wird kein Guide erzeugt; andernfalls bezeichne g das Ergebnis der Substitution, ein Guide f' wird gebildet, so dass

• Die Parametertypen und der Rückgabetyp von f' sind dieselben wie bei g
• Wenn f ein Template ist, f' ist ein Funktions-Template, dessen Template-Parameterliste alle Template-Parameter von A (einschließlich ihrer Standard-Template-Argumente) enthält, die in den obigen Deduktionen oder (rekursiv) in ihren Standard-Template-Argumenten vorkommen, gefolgt von den Template-Parametern von f , die nicht deduziert wurden (einschließlich ihrer Standard-Template-Argumente); andernfalls ( f ist kein Template), f' ist eine Funktion
• Die assoziierten Constraints von f' sind die Konjunktion der assoziierten Constraints von g und eines Constraints, das genau dann erfüllt ist, wenn die Argumente von A aus dem Ergebnistyp deduzierbar sind

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[]>;
// generierter Guide für unique_ptr_nonarray:
// aus #1 (Deduktion von unique_ptr<T> aus unique_ptr<A> ergibt T = A):
// template<class A>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<A>>)
// auto F(A*) -> unique_ptr<A>;
// aus #2 (Deduktion von unique_ptr<T[]> aus unique_ptr<A> ergibt nichts):
// template<class T>
//     requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<T[]>>)
// auto F(T*) -> unique_ptr<T[]>;
// wobei argument_of_unique_ptr_nonarray_is_deducible_from definiert werden kann als
// 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>); };
// generierter Guide für unique_ptr_array:
// aus #1 (Deduktion von unique_ptr<T> aus unique_ptr<A[]> ergibt T = A[]):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A(*)[]) -> unique_ptr<A[]>;
// aus #2 (Deduktion von unique_ptr<T[]> aus unique_ptr<A[]> ergibt T = A):
// template<class A>
//     requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)
// auto F(A*) -> unique_ptr<A[]>;
// wobei argument_of_unique_ptr_array_is_deducible_from definiert werden kann als
// 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>); };
// Verwendung:
unique_ptr_nonarray p(new int); // deduziert zu unique_ptr<int>
// Deduktion-Guide generiert aus #1 gibt unique_ptr<int> zurück
// Deduktion-Guide generiert aus #2 gibt unique_ptr<int[]> zurück, was ignoriert wird, weil
//   argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<int[]>> unerfüllt ist
unique_ptr_array q(new int[42]); // deduziert zu unique_ptr<int[]>
// Deduktion-Guide generiert aus #1 schlägt fehl (kann A in A(*)[] nicht aus new int[42] deduzieren)
// Deduktion-Guide generiert aus #2 gibt unique_ptr<int[]> zurück