Réponse.

Historique de la question :

Les modèles ont été ajoutés à C++ pour une mise en œuvre efficace d'algorithmes et de structures de données génériques. Dès le début, un mécanisme d'inférence automatique des types en fonction des arguments d'entrée était nécessaire pour faciliter l'utilisation des modèles par les développeurs.

Problème :

Le mécanisme d'inférence n'est pas toujours évident : il y a des ambiguïtés concernant les références, le masquage des types, les spécialisations partielles, les paramètres de modèles par référence et les constantes. Parfois, le compilateur ne peut pas déduire le type ou produit un résultat inattendu.

Solution :

Le compilateur analyse les arguments, les associe aux paramètres de modèle, en tenant compte des règles de qualification cv, des références et des pointeurs. Les inconvénients et les limitations nécessitent une indication explicite du type lorsque l'inférence automatique est impossible.

Exemple de code :

template<typename T>
void func(T arg) { /* ... */ }

func(10);        // T déduit comme int
func("abc");    // T déduit comme const char*

// Différence entre T arg et T& arg :
template<typename T>
void printRef(T& arg); // N'acceptera pas un objet temporaire !

Caractéristiques clés :

L'inférence ne fonctionne pas avec T& pour les objets temporaires.
Les qualificatifs CV (const/volatile) influencent le type déduit.
Règles spéciales pour les pointeurs et les tableaux (decay).

Questions piégées.

Que se passe-t-il si une fonction modèle prend T& et que vous essayez de lui passer un objet temporaire ?

Le compilateur ne pourra pas effectuer l'inférence de type, car un objet temporaire ne peut pas être passé par référence non constante. Une erreur de compilation se produira.

template<typename T>
void foo(T& arg);

foo(42); // Erreur !

Comment fonctionne l'inférence de types avec des tableaux ?

Les tableaux se "décayent" en pointeurs lors d'un passage par valeur, mais si le modèle prend une référence, la taille du tableau est conservée, ce qui est souvent utilisé pour la mise en œuvre de modèles à taille sécurisée.

template<typename T, size_t N>
void arraySize(T (&arr)[N]) { std::cout << N; }

int x[10];
arraySize(x); // Affichera 10

Pourquoi n'est-il pas toujours correct d'utiliser auto pour stocker les résultats d'appels de fonctions modèles ?

Auto lors de l'inférence de type peut "découper" le qualificatif const ou ref, ce qui conduit parfois à des erreurs inattendues de copie ou de mutabilité.

auto x = funcReturningRef(); // x sera par valeur, et non par référence !

Erreurs typiques et anti-modèles

Utilisation de références non constantes (T&) pour des objets temporaires.
Erreurs non évidentes lors de la décomposition des tableaux et des pointeurs.
Attente que l'inférence de paramètres "devine" toujours le bon type.

Exemple de la vie réelle

Cas négatif

Une fonction modèle de tri universel prend T&, l'utilisateur essaie de passer un objet temporaire. En conséquence, le code ne compile pas, et l'erreur déroute le développeur.

Avantages :

Protection contre les modifications accidentelles des objets temporaires.

Inconvénients :

Limitation significative de la flexibilité de l'interface.
Messages d'erreur du compilateur déroutants.

Cas positif

Le tri est réalisé via des références universelles (T&&) en utilisant std::forward, ce qui permet de travailler correctement avec les lvalues et les rvalues, augmentant ainsi les performances et la flexibilité.