Déduction d'Argument de Modèle de Classe

Vous avez peut-être déjà utilisé certains d'entre eux sans réaliser qu'ils étaient des modèles au départ, peut-être en raison de la Déduction d'Argument de Modèle de Classe (CTAD).

Avec C++17, nous pouvons tirer parti de la Déduction d'Argument de Modèle de Classe (CTAD). Cette fonctionnalité nous permet de créer des instances de nos classes modèles sans spécifier explicitement les types de modèles. Au lieu de cela, le compilateur déduit les types en fonction des paramètres du constructeur. Regardons quelques exemples en utilisant std::pair.

main


              12345678
            
#include <iostream>
#include <utility> // for std::pair

int main()
{
    std::pair<int, char> my_pair(1, 'a');
    std::cout << my_pair.first << " : " << my_pair.second << std::endl;
}

Remarque

Auparavant, c'était la seule façon de créer une instance de std::pair. Cependant, il est maintenant possible d'omettre la partie <int, char>. Essayez de la supprimer et exécutez à nouveau le code.

La déduction des arguments de modèle de classe n'est effectuée que si aucune liste d'arguments de modèle n'est présente. Si une liste d'arguments de modèle est spécifiée, la déduction n'a pas lieu.

main


              12345678
            
#include <iostream>
#include <utility> // for std::pair

int main()
{
    std::pair<> my_pair(1, 'a'); // Error
    std::cout << my_pair.first << " : " << my_pair.second << std::endl;
}

Lors de la création d'un objet avec un seul argument qui correspond à un type spécifique d'un modèle de classe, CTAD préfère utiliser ce type directement, simplifiant ainsi l'instanciation pour les classes de modèles définies par l'utilisateur. Par exemple, avec une classe modèle comme Box, les utilisateurs peuvent l'instancier sans spécifier d'arguments de type lorsqu'ils fournissent des arguments au constructeur.

main


              123456789101112131415
            
#include <iostream>

template <typename T>
class Box {
    T value;
public:
    Box(T value): value(value) {}
};

int main()
{
	// No need to write Box<int> a{1};
    Box a{1}; // Deduction: Box<int>
    Box b{a}; // Deduction: Box<int>, not Box<Box<int>>
}

CTAD peut faciliter la maintenance du code. Si les types sous-jacents changent, il y a moins de code à mettre à jour, ce qui réduit les opportunités d'erreurs.

vector


              12345678
            
template <typename T>
class Vector3D {
    T x, y, z;
public:
    Vector3D(T x, T y, T z) : x(x), y(y), z(z) {}
};

Vector3D vec{1.0, 2.0, 3.0}; // CTAD deduces Vector3D<double>

Lors de l'utilisation de conteneurs ou d'enveloppes avec des constructeurs spécifiques, CTAD peut simplifier le code. Supposons que vous ayez une classe Matrix ou Vector personnalisée qui encapsule un type de données sous-jacent. L'utilisation de CTAD ici peut aider à garantir que la déduction de type se produit automatiquement en fonction des arguments fournis, améliorant ainsi la lisibilité et la flexibilité.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 4