Template argument deduction

Afin d'instancier une function template , chaque argument de template doit être connu, mais il n'est pas nécessaire que chaque argument de template soit spécifié. Lorsque cela est possible, le compilateur déduira les arguments de template manquants à partir des arguments de la fonction. Cela se produit lors d'une tentative d'appel de fonction, lors de la prise d'adresse d'une function template, et dans certains autres contextes :

template<typename To, typename From>
To convert(From f);
void g(double d)
{
    int i = convert<int>(d);    // appelle convert<int, double>(double)
    char c = convert<char>(d);  // appelle convert<char, double>(double)
    int(*ptr)(float) = convert; // instancie convert<int, float>(float)
                                // et stocke son adresse dans ptr
}

Ce mécanisme permet d'utiliser des opérateurs template, puisqu'il n'existe pas de syntaxe pour spécifier des arguments template pour un opérateur autrement qu'en le réécrivant comme une expression d'appel de fonction :

#include <iostream>
int main()
{
    std::cout << "Hello, world" << std::endl;
    // operator<< est recherché via ADL comme std::operator<<,
    // puis déduit en operator<<<char, std::char_traits<char>> les deux fois
    // std::endl est déduit en &std::endl<char, std::char_traits<char>>
}

La déduction des arguments de template a lieu après la recherche de nom du template de fonction (qui peut impliquer une recherche dépendante des arguments ) et avant la substitution des arguments de template (qui peut impliquer SFINAE ) et la résolution de surcharge .

std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);
std::copy_n(vi1, 3, std::back_insert_iterator(vi2));
std::for_each(vi.begin(), vi.end(), Foo([&](int i) {...}));
auto lck = std::lock_guard(foo.mtx);
std::lock_guard lck2(foo.mtx, ul);

Déduction à partir d'un appel de fonction

La déduction d'arguments de template tente de déterminer les arguments de template (types pour les paramètres de template de type T i, templates pour les paramètres de template de template TT i, et valeurs pour les paramètres de template constants I i), qui peuvent être substitués dans chaque paramètre P pour produire le type déduit A , qui est le même que le type de l'argument A , après les ajustements listés ci-dessous.

S'il y a plusieurs paramètres, chaque paire P / A est déduite séparément et les arguments de modèle déduits sont ensuite combinés. Si la déduction échoue ou est ambiguë pour une paire P / A quelconque, ou si différentes paires produisent des arguments de modèle déduits différents, ou si un argument de modèle reste ni déduit ni explicitement spécifié, la compilation échoue.

template<class T>
void f(std::initializer_list<T>);
f({1, 2, 3});  // P = std::initializer_list<T>, A = {1, 2, 3}
               // P'1 = T, A'1 = 1: déduit T = int
               // P'2 = T, A'2 = 2: déduit T = int
               // P'3 = T, A'3 = 3: déduit T = int
               // OK: déduit T = int
f({1, "abc"}); // P = std::initializer_list<T>, A = {1, "abc"}
               // P'1 = T, A'1 = 1: déduit T = int
               // P'2 = T, A'2 = "abc": déduit T = const char*
               // erreur: la déduction échoue, T est ambigu

template<class T, int N>
void h(T const(&)[N]);
h({1, 2, 3}); // déduit T = int, déduit N = 3
template<class T>
void j(T const(&)[3]);
j({42}); // déduit T = int, la borne du tableau n'est pas un paramètre, non considérée
struct Aggr
{
    int i;
    int j;
};
template<int N>
void k(Aggr const(&)[N]);
k({1, 2, 3});       // erreur: la déduction échoue, pas de conversion de int vers Aggr
k({{1}, {2}, {3}}); // OK: déduit N = 3
template<int M, int N>
void m(int const(&)[M][N]);
m({{1, 2}, {3, 4}}); // déduit M = 2, déduit N = 2
template<class T, int N>
void n(T const(&)[N], T);
n({{1}, {2}, {3}}, Aggr()); // déduit T = Aggr, déduit N = 3

template<class... Types>
void f(Types&...);
void h(int x, float& y)
{
    const int z = x;
    f(x, y, z); // P = Types&..., A1 = x: déduit premier membre de Types... = int
                // P = Types&..., A2 = y: déduit deuxième membre de Types... = float
                // P = Types&..., A3 = z: déduit troisième membre de Types... = const int
                // appelle f<int, float, const int>
}

Si P est un type de fonction, un type de pointeur vers fonction, ou un type de pointeur vers fonction membre et si A est un ensemble de fonctions surchargées ne contenant pas de modèles de fonction, la déduction d'argument de modèle est tentée avec chaque surcharge. Si une seule réussit, cette déduction réussie est utilisée. Si aucune ou plus d'une réussit, le paramètre de modèle est un contexte non déduit (voir ci-dessous) :

template<class T>
int f(T(*p)(T));
int g(int);
int g(char);
f(g); // P = T(*)(T), A = ensemble de surcharge
      // P = T(*)(T), A1 = int(int): T déduit = int
      // P = T(*)(T), A2 = int(char): échec de déduction de T
      // une seule surcharge fonctionne, la déduction réussit

Avant que la déduction ne commence, les ajustements suivants à P et A sont effectués :

template<class T>
void f(T);
int a[3];
f(a); // P = T, A = int[3], ajusté en int* : T déduit = int*
void b(int);
f(b); // P = T, A = void(int), ajusté en void(*)(int) : T déduit = void(*)(int)
const int c = 13;
f(c); // P = T, A = const int, ajusté en int : T déduit = int

template<class T>
int f(T&&);       // P est une référence à valeur r vers T non qualifié cv (référence de transfert)
template<class T>
int g(const T&&); // P est une référence à valeur r vers T qualifié cv (pas spécial)
int main()
{
    int i;
    int n1 = f(i); // l'argument est une lvalue : appelle f<int&>(int&) (cas spécial)
    int n2 = f(0); // l'argument n'est pas une lvalue : appelle f<int>(int&&)
//  int n3 = g(i); // erreur : déduit g<int>(const int&&), qui
                   // ne peut pas lier une référence à valeur r à une lvalue
}

Après ces transformations, le processus de déduction se déroule comme décrit ci-dessous (cf. section déduction à partir d'un type ) et tente de trouver des arguments de template tels qu'ils rendraient le A déduit (c'est-à-dire, P après les ajustements listés ci-dessus et la substitution des paramètres de template déduits) identique au transformé A , c'est-à-dire A après les ajustements listés ci-dessus.

Si la déduction habituelle à partir de P et A échoue, les alternatives suivantes sont également considérées :

template<typename T>
void f(const T& t);
bool a = false;
f(a); // P = const T&, adjusted to const T, A = bool:
      // deduced T = bool, deduced A = const bool
      // deduced A is more cv-qualified than A

template<typename T>
void f(const T*);
int* p;
f(p); // P = const T*, A = int*:
      // T déduit = int, A déduit = const int*
      // la conversion de qualification s'applique (de int* vers const int*)

template<class T>
struct B {};
template<class T>
struct D : public B<T> {};
template<class T>
void f(B<T>&) {}
void f()
{
    D<int> d;
    f(d); // P = B<T>&, ajusté à P = B<T> (un simple-template-id), A = D<int>:
          // T déduit = int, A déduit = B<int>
          // A est dérivé de A déduit
}

Contextes non déduits

Dans les cas suivants, les types, modèles et constantes utilisés pour composer P ne participent pas à la déduction des arguments de modèle, mais utilisent plutôt les arguments de modèle qui ont été soit déduits ailleurs, soit explicitement spécifiés. Si un paramètre de modèle est utilisé uniquement dans des contextes non déduits et n'est pas explicitement spécifié, la déduction des arguments de modèle échoue.

// le modèle d'identité, souvent utilisé pour exclure des arguments spécifiques de la déduction
// (disponible sous le nom std::type_identity à partir de C++20)
template<typename T>
struct identity { typedef T type; };
template<typename T>
void bad(std::vector<T> x, T value = 1);
template<typename T>
void good(std::vector<T> x, typename identity<T>::type value = 1);
std::vector<std::complex<double>> x;
bad(x, 1.2);  // P1 = std::vector<T>, A1 = std::vector<std::complex<double>>
              // P1/A1: T déduit = std::complex<double>
              // P2 = T, A2 = double
              // P2/A2: T déduit = double
              // erreur: la déduction échoue, T est ambigu
good(x, 1.2); // P1 = std::vector<T>, A1 = std::vector<std::complex<double>>
              // P1/A1: T déduit = std::complex<double>
              // P2 = identity<T>::type, A2 = double
              // P2/A2: utilise T déduit par P1/A1 car T est à gauche de :: dans P2
              // OK: T = std::complex<double>

template<typename... Ts>
void f(Ts...[0], std::tuple<Ts...>);
f(3, std::tuple(5, 'A'));
// P2 = std::tuple<Ts...>, A2 = std::tuple<int, char>
// P2/A2: deduced first member of Ts... = int
// P2/A2: deduced second member of Ts... = char
// P1 = Ts...[0], A1 = int: Ts...[0] is in non-deduced context

template<typename T>
void f(decltype(*std::declval<T>()) arg);
int n;
f<int*>(n); // P = decltype(*declval<T>()), A = int: T is in non-deduced context

template<std::size_t N>
void f(std::array<int, 2 * N> a);
std::array<int, 10> a;
f(a); // P = std::array<int, 2 * N>, A = std::array<int, 10>:
      // 2 * N est un contexte non déduit, N ne peut pas être déduit
      // note : f(std::array<int, N> a) permettrait de déduire N

template<typename T, typename F>
void f(const std::vector<T>& v, const F& comp = std::less<T>());
std::vector<std::string> v(3);
f(v); // P1 = const std::vector<T>&, A1 = std::vector<std::string> lvalue
      // P1/A1 deduced T = std::string
      // P2 = const F&, A2 = std::less<std::string> rvalue
      // P2 is non-deduced context for F (template parameter) used in the
      // parameter type (const F&) of the function parameter comp,
      // that has a default argument that is being used in the call f(v)

template<typename T>
void out(const T& value) { std::cout << value; }
out("123");     // P = const T&, A = const char[4] lvalue: deduced T = char[4]
out(std::endl); // P = const T&, A = function template: T is in non-deduced context

template<class T>
void g1(std::vector<T>);
template<class T>
void g2(std::vector<T>, T x);
g1({1, 2, 3});     // P = std::vector<T>, A = {1, 2, 3}: T est dans un contexte non déduit
                   // erreur : T n'est pas explicitement spécifié ou déduit d'un autre P/A
g2({1, 2, 3}, 10); // P1 = std::vector<T>, A1 = {1, 2, 3}: T est dans un contexte non déduit
                   // P2 = T, A2 = int: T déduit = int

template<class... Ts, class T>
void f1(T n, Ts... args);
template<class... Ts, class T>
void f2(Ts... args, T n);
f1(1, 2, 3, 4); // P1 = T, A1 = 1: déduit T = int
                // P2 = Ts..., A2 = 2, A3 = 3, A4 = 4: déduit Ts = [int, int, int]
f2(1, 2, 3, 4); // P1 = Ts...: Ts est un contexte non déduit

template<int...>
struct T {};
template<int... Ts1, int N, int... Ts2>
void good(const T<N, Ts1...>& arg1, const T<N, Ts2...>&);
template<int... Ts1, int N, int... Ts2>
void bad(const T<Ts1..., N>& arg1, const T<Ts2..., N>&);
T<1, 2> t1;
T<1, -1, 0> t2;
good(t1, t2); // P1 = const T<N, Ts1...>&, A1 = T<1, 2>:
              // déduit N = 1, déduit Ts1 = [2]
              // P2 = const T<N, Ts2...>&, A2 = T<1, -1, 0>:
              // déduit N = 1, déduit Ts2 = [-1, 0]
bad(t1, t2);  // P1 = const T<Ts1..., N>&, A1 = T<1, 2>:
              // <Ts1..., N> est un contexte non déduit
              // P2 = const T<Ts2..., N>&, A2 = T<1, -1, 0>:
              // <Ts2..., N> est un contexte non déduit

template<int i>
void f1(int a[10][i]);
template<int i>
void f2(int a[i][20]);    // P = int[i][20], array type
template<int i>
void f3(int (&a)[i][20]); // P = int(&)[i][20], reference to array
void g()
{
    int a[10][20];
    f1(a);     // OK: déduit i = 20
    f1<20>(a); // OK
    f2(a);     // erreur: i est un contexte non déduit
    f2<10>(a); // OK
    f3(a);     // OK: déduit i = 10
    f3<10>(a); // OK
}

Dans tous les cas, si une partie d'un nom de type est non déduite, l'ensemble du nom de type est un contexte non déduit. Cependant, les types composés peuvent inclure à la fois des noms de types déduits et non déduits. Par exemple, dans A < T > :: B < T2 > , T est non déduit en raison de la règle n°1 (spécificateur de nom imbriqué), et T2 est non déduit car il fait partie du même nom de type, mais dans void ( * f ) ( typename A < T > :: B , A < T > ) , le T dans A < T > :: B est non déduit (en raison de la même règle), tandis que le T dans A < T > est déduit.

Déduction à partir d'un type

Étant donné un paramètre de fonction P qui dépend d'un ou plusieurs paramètres de template de type T i, de paramètres de template de template TT i, ou de paramètres de template constants I i, et l'argument correspondant A , la déduction a lieu si P a l'une des formes suivantes :

• cv (optionnel) T ;
• T* ;
• T& ;

• T (optionnel) [ I (optionnel) ] ;

• T (optionnel) U (optionnel) ::* ;
• TT (optionnel) <T> ;
• TT (optionnel) <I> ;
• TT (optionnel) <TU> ;
• TT (optionnel) <> .

Dans les formulaires ci-dessus,

• T (optionnel) ou U (optionnel) représente un type ou parameter-type-list qui satisfait soit ces règles récursivement, soit est un contexte non déduit dans P ou A , soit est le même type non dépendant dans P et A .
• TT (optionnel) ou TU (optionnel) représente soit un modèle de classe soit un paramètre de modèle de modèle.
• I (optionnel) représente une expression qui soit est un I , soit dépend des valeurs dans P ou A , soit a la même valeur constante dans P et A .

Si P a l'une des formes qui inclut une liste de paramètres template <T> ou <I> , alors chaque élément P i de cette liste d'arguments template est comparé à l'argument template correspondant A i de son A . Si le dernier P i est une expansion de pack, alors son motif est comparé à chaque argument restant dans la liste d'arguments template de A . Un parameter pack final qui n'est pas autrement déduit est déduit comme un parameter pack vide.

Si P a l'une des formes qui incluent une liste de paramètres de fonction (T) , alors chaque paramètre P i de cette liste est comparé avec l'argument correspondant A i de la liste de paramètres de fonction de A . Si le dernier P i est une expansion de paquet, alors son déclarateur est comparé avec chaque A i restant dans la liste de types de paramètres de A .

Les formulaires peuvent être imbriqués et traités de manière récursive :

• X < int > ( * ) ( char [ 6 ] ) est un exemple de T* , où T est X < int > ( char [ 6 ] ) ;

• X < int > est un exemple de TT (optionnel) <T> , où TT est X et T est int , et
• char [ 6 ] est un exemple de T (optionnel) [ I (optionnel) ] , où T est char et I est std:: size_t ( 6 ) .

template<typename T, T i>
void f(double a[10][i]);
double v[10][20];
f(v); // P = double[10][i], A = double[10][20]:
      // i peut être déduit comme égal à 20
      // mais T ne peut pas être déduit du type de i

template<long n>
struct A {};
template<class T>
struct C;
template<class T, T n>
struct C<A<n>> { using Q = T; };
typedef long R;
typedef C<A<2>>::Q R; // OK : T a été déduit comme long
                      // à partir de la valeur d'argument template dans le type A<2>
template<auto X>
class bar {};
template<class T, T n>
void f(bar<n> x);
f(bar<3>{}); // OK : T a été déduit comme int (et n comme 3)
             // à partir de la valeur d'argument template dans le type bar<3>

template<class T, T i>
void f(int (&a)[i]);
int v[10];
f(v); // OK : T est std::size_t

template<bool>
struct A {};
template<auto>
struct B;
template<auto X, void (*F)() noexcept(X)>
struct B<F> { A<X> ax; };
void f_nothrow() noexcept;
B<f_nothrow> bn; // OK : X est déduit comme true et le type de X est déduit comme bool.

Si un paramètre de modèle constant d'un modèle de fonction est utilisé dans la liste des paramètres de modèle d'un paramètre de fonction (qui est également un modèle), et que l'argument de modèle correspondant est déduit, le type de l'argument de modèle déduit (tel que spécifié dans sa liste de paramètres de modèle englobante, ce qui signifie que les références sont préservées) doit correspondre exactement au type du paramètre de modèle constant, sauf que les qualificateurs cv sont supprimés, et sauf lorsque l'argument de modèle est déduit d'une limite de tableau—dans ce cas, tout type intégral est autorisé, même bool bien qu'il devienne toujours true :

template<int i>
class A {};
template<short s>
void f(A<s>); // le type du paramètre de template constant est short
void k1()
{
    A<1> a;  // le type du paramètre de template constant de a est int
    f(a);    // P = A<(short)s>, A = A<(int)1>
             // erreur : l'argument de template constant déduit n'a pas le même
             // type que son argument de template correspondant
    f<1>(a); // OK : l'argument de template n'est pas déduit,
             // ceci appelle f<(short)1>(A<(short)1>)
}
template<int&>
struct X;
template<int& R>
void k2(X<R>&);
int n;
void g(X<n> &x)
{
    k2(x); // P = X<R>, A = X<n>
           // le type du paramètre est int&
           // le type de l'argument est int& dans la déclaration du template de struct X
           // OK (avec CWG 2091) : déduit que R fait référence à n
}

Le paramètre de modèle de type ne peut pas être déduit du type d'un argument par défaut de fonction :

template<typename T>
void f(T = 5, T = 7);
void g()
{
    f(1);     // OK : appelle f<int>(1, 7)
    f();      // erreur : impossible de déduire T
    f<int>(); // OK : appelle f<int>(5, 7)
}

La déduction des paramètres template template peut utiliser le type utilisé dans la spécialisation de template utilisée dans l'appel de fonction :

template<template<typename> class X>
struct A {}; // A est un template avec un paramètre TT
template<template<typename> class TT>
void f(A<TT>) {}
template<class T>
struct B {};
A<B> ab;
f(ab); // P = A<TT>, A = A<B>: TT déduit = B, appelle f(A<B>)

Autres contextes

En plus des appels de fonction et des expressions d'opérateur, la déduction d'arguments de template est utilisée dans les situations suivantes :

const auto& x = 1 + 2; // P = const U&, A = 1 + 2:
                       // mêmes règles que pour l'appel f(1 + 2) où f est
                       // template<class U> void f(const U& u)
                       // U déduit = int, le type de x est const int&
auto l = {13}; // P = std::initializer_list<U>, A = {13}:
               // U déduit = int, le type de l est std::initializer_list<int>

auto x1 = {3}; // x1 est std::initializer_list<int>
auto x2{1, 2}; // erreur : pas un seul élément
auto x3{3};    // x3 est int
               // (avant N3922 x2 et x3 étaient tous deux std::initializer_list<int>)

auto f() { return 42; } // P = auto, A = 42:
                        // U déduit = int, le type de retour de f est int

Résolution de surcharge

La déduction d'argument de template est utilisée pendant la résolution de surcharge , lors de la génération de spécialisations à partir d'une fonction template candidate. P et A sont les mêmes que dans un appel de fonction régulier :

std::string s;
std::getline(std::cin, s);
// "std::getline" nomme 4 modèles de fonctions,
// dont 2 sont des fonctions candidates (nombre correct de paramètres)
// 1er modèle candidat :
// P1 = std::basic_istream<CharT, Traits>&, A1 = std::cin
// P2 = std::basic_string<CharT, Traits, Allocator>&, A2 = s
// la déduction détermine les paramètres de type CharT, Traits et Allocator
// spécialisation std::getline<char, std::char_traits<char>, std::allocator<char>>
// 2ème modèle candidat :
// P1 = std::basic_istream<CharT, Traits>&&, A1 = std::cin
// P2 = std::basic_string<CharT, Traits, Allocator>&, A2 = s
// la déduction détermine les paramètres de type CharT, Traits et Allocator
// spécialisation std::getline<char, std::char_traits<char>, std::allocator<char>>
// la résolution de surcharge classe la liaison de référence à partir de la lvalue std::cin
// et sélectionne la première des deux spécialisations candidates

Si la déduction échoue, ou si la déduction réussit, mais que la spécialisation qu'elle produit serait invalide (par exemple, un opérateur surchargé dont les paramètres ne sont ni des types classe ni des types énumération), la spécialisation n'est pas incluse dans l'ensemble des surcharges, similaire à SFINAE .

Adresse d'un ensemble de surcharge

La déduction d'argument de template est utilisée lors de la prise d'une adresse d'un ensemble surchargé , qui inclut les function templates.

Le type de fonction du modèle de fonction est P . Le type cible est le type de A :

std::cout << std::endl;
// std::endl désigne un modèle de fonction
// type de endl P =
// std::basic_ostream<CharT, Traits>& (std::basic_ostream<CharT, Traits>&)
// paramètre A de operator<< =
// std::basic_ostream<char, std::char_traits<char>>& (*)(
//   std::basic_ostream<char, std::char_traits<char>>&
// )
// (les autres surcharges de operator<< ne sont pas viables)
// la déduction détermine les paramètres de type template CharT et Traits

Une règle supplémentaire est appliquée à la déduction dans ce cas : lors de la comparaison des paramètres de fonction P i et A i, si un P i est une référence à valeur droite vers un paramètre de template non qualifié cv (une "forwarding reference") et le A i correspondant est une référence à valeur gauche, alors P i est ajusté au type du paramètre de template (T&& devient T).

Ordonnancement partiel

La déduction des arguments de template est utilisée lors de la mise en ordre partielle des surcharges de templates de fonction .

Modèle de fonction de conversion

La déduction d'argument de template est utilisée lors de la sélection des arguments de template de fonction de conversion définie par l'utilisateur .

A est le type requis comme résultat de la conversion. P est le type de retour du modèle de fonction de conversion. Si P est un type référence, alors le type référencé est utilisé à la place de P pour les parties suivantes de la section.

Si A n'est pas un type référence :

Si A est qualifié cv, les qualificatifs cv de plus haut niveau sont ignorés. Si A est un type référence, le type référencé est utilisé pour la déduction.

Si la déduction habituelle à partir de P et A (comme décrit ci-dessus) échoue, les alternatives suivantes sont également considérées :

struct C
{
    template<class T>
    operator T***();
};
C c;
const int* const* const* p1 = c;
// P = T***, A = const int* const* const*
// déduction d'appel de fonction régulière pour
// template<class T> void f(T*** p) comme si appelée avec l'argument
// de type const int* const* const* échoue
// déduction supplémentaire pour les fonctions de conversion détermine T = int
// (A déduit est int***, convertible en const int* const* const*)

Voir member template pour les autres règles concernant les modèles de fonction de conversion.

Instanciation explicite

La déduction d'arguments de template est utilisée dans les instanciations explicites , les spécialisations explicites , et ces déclarations friend où le declarator-id fait référence à une spécialisation d'un template de fonction (par exemple, friend ostream & operator << <> ( ... ) ), si tous les arguments de template ne sont pas explicitement spécifiés ou par défaut, la déduction d'arguments de template est utilisée pour déterminer à quelle spécialisation de template il est fait référence.

P est le type du modèle de fonction qui est considéré comme une correspondance potentielle, et A est le type de fonction provenant de la déclaration. S'il n'y a aucune correspondance ou plus d'une correspondance (après classement partiel), la déclaration de fonction est mal formée :

template<class X>
void f(X a);        // 1er template f
template<class X>
void f(X* a);       // 2ème template f
template<>
void f<>(int* a) {} // spécialisation explicite de f
// P1 = void(X), A1 = void(int*): X déduit = int*, f<int*>(int*)
// P2 = void(X*), A2 = void(int*): X déduit = int, f<int>(int*)
// f<int*>(int*) et f<int>(int*) sont ensuite soumis à l'ordre partiel
// qui sélectionne f<int>(int*) comme le template le plus spécialisé

Une règle supplémentaire s'applique à la déduction dans ce cas : lors de la comparaison des paramètres de fonction P i et A i, si un P i est une référence à valeur droite vers un paramètre de template non qualifié cv (une "forwarding reference") et le A i correspondant est une référence à valeur gauche, alors P i est ajusté au type du paramètre de template (T&& devient T).

Modèle de fonction de désallocation

La déduction d'argument de template est utilisée pour déterminer si une fonction de désallocation spécialisation de template correspond à une forme placement donnée de operator new .

P est le type du modèle de fonction qui est considéré comme une correspondance potentielle, et A est le type de fonction de la fonction de désallocation qui serait la correspondance pour l'opérateur new de placement considéré. S'il n'y a pas de correspondance ou plus d'une correspondance (après résolution de surcharge), la fonction de désallocation de placement n'est pas appelée (une fuite de mémoire peut se produire) :

struct X
{
    X() { throw std::runtime_error(""); }
    static void* operator new(std::size_t sz, bool b)   { return ::operator new(sz); }
    static void* operator new(std::size_t sz, double f) { return ::operator new(sz); }
    template<typename T>
    static void operator delete(void* ptr, T arg)
    {
        ::operator delete(ptr);
    }
};
int main()
{
    try
    {
        X* p1 = new (true) X; // lorsque X() lance une exception, operator delete est recherché
                              // P1 = void(void*, T), A1 = void(void*, bool) :
                              // T déduit = bool
                              // P2 = void(void*, T), A2 = void(void*, double) :
                              // T déduit = double
                              // la résolution de surcharge sélectionne operator delete<bool>
    }
    catch(const std::exception&) {}
    try
    {
        X* p1 = new (13.2) X; // même recherche, sélectionne operator delete<double>
    }
    catch(const std::exception&) {}
}

Modèles d'alias

Les modèles d'alias ne sont pas déduits , sauf dans la déduction d'arguments de modèle de classe (depuis C++20) :

template<class T>
struct Alloc {};
template<class T>
using Vec = vector<T, Alloc<T>>;
Vec<int> v;
template<template<class, class> class TT>
void g(TT<int, Alloc<int>>);
g(v); // OK : déduit TT = vector
template<template<class> class TT>
void f(TT<int>);
f(v); // erreur : TT ne peut pas être déduit comme "Vec" car Vec est un alias template

Conversions implicites

La déduction de type ne prend pas en compte les conversions implicites (autres que les ajustements de type listés ci-dessus) : c'est le rôle de la résolution de surcharge , qui intervient ultérieurement. Cependant, si la déduction réussit pour tous les paramètres participant à la déduction d'arguments de template, et que tous les arguments de template non déduits sont explicitement spécifiés ou par défaut, alors les paramètres de fonction restants sont comparés avec les arguments de fonction correspondants. Pour chaque paramètre restant P dont le type était non dépendant avant la substitution de tout argument de template explicitement spécifié, si l'argument correspondant A ne peut pas être implicitement converti en P , la déduction échoue.

Les paramètres avec des types dépendants dans lesquels aucun paramètre de template ne participe à la déduction d'arguments de template, et les paramètres devenus non-dépendants en raison de la substitution d'arguments de template explicitement spécifiés seront vérifiés lors de la résolution de surcharge :

template<class T>
struct Z { typedef typename T::x xx; };
template<class T>
typename Z<T>::xx f(void*, T); // #1
template<class T>
void f(int, T);                // #2
struct A {} a;
int main()
{
    f(1, a); // pour #1, la déduction détermine T = struct A, mais l'argument restant 1
             // ne peut pas être implicitement converti en son paramètre void* : la déduction échoue
             // l'instanciation du type de retour n'est pas demandée
             // pour #2, la déduction détermine T = struct A, et l'argument restant 1
             // peut être implicitement converti en son paramètre int : la déduction réussit
             // l'appel de fonction compile comme un appel à #2 (l'échec de déduction est SFINAE)
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.