Apprendre Déduction des Arguments de Modèle de Classe

Glissez pour afficher le menu

Vous avez peut-être déjà utilisé certains d'entre eux sans réaliser qu'il s'agissait de templates au départ, possiblement grâce à la déduction d'arguments de template de classe (CTAD).

Avec C++17, il est possible de profiter de la déduction d'arguments de template de classe (CTAD). Cette fonctionnalité permet de créer des instances de classes template sans spécifier explicitement les types de template. À la place, le compilateur déduit les types à partir des paramètres du constructeur. Voici quelques exemples utilisant std::pair.

main.cpp


              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. Désormais, il est 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.cpp


              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 correspondant à un type spécifique d'un modèle de classe, la déduction automatique des arguments de modèle de classe (CTAD) privilégie l'utilisation directe de ce type, simplifiant ainsi l'instanciation pour les classes modèles définies par l'utilisateur. Par exemple, avec une classe modèle comme Box, il est possible de l'instancier sans spécifier les arguments de type lors de la fourniture des arguments du constructeur.

main.cpp


              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 à modifier, ce qui réduit les risques d'erreurs.

vector.h


              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, la déduction d'argument de modèle de classe (CTAD) peut simplifier le code. Supposons que vous ayez une classe personnalisée Matrix ou Vector qui encapsule un type de données sous-jacent. L'utilisation de CTAD ici permet de garantir que la déduction de type se fait 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

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 3. Chapitre 4