0Pricing
C++ Academy · Leçon

Modèles de fonctions et de classes : révision

Écrire des fonctions et des classes génériques avec une syntaxe de modèle correcte

Modèles de fonctions et de classes : révision est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Pourquoi utiliser des modèles ?

Les modèles vous permettent d’écrire le code une seule fois et de laisser le compilateur générer des versions spécifiques pour chaque type utilisé. C’est la pierre angulaire de la programmation générique.

Syntaxe des modèles de fonctions

Déclarez les paramètres de type avec template <typename T>. Utilisez T dans la signature de la fonction.

template <typename T>
T max_of(T a, T b) {
    return (a > b) ? a : b;
}

std::cout << max_of(3, 7);          // int
std::cout << max_of(2.5, 1.5);      // double

typename ou classe

Les mots-clés typename et class sont interchangeables dans les déclarations de paramètres de modèle. typename est plus courant dans le style moderne.

Plusieurs paramètres de type

Les modèles peuvent comporter plusieurs paramètres de type.

template <typename T, typename U>
auto combine(T a, U b) -> decltype(a + b) {
    return a + b;
}

Paramètres qui ne sont pas des types

Les paramètres de modèle peuvent également être des valeurs qui ne sont pas des types : des entiers, des énumérations ou des pointeurs.

template <typename T, size_t N>
struct StaticArray {
    T data[N];
};

StaticArray<int, 10> arr;

Modèles de classes

Les classes génériques utilisent la même syntaxe de modèle. Utilisez le paramètre de type pour les membres et les méthodes.

template <typename T>
class Stack {
    std::vector<T> data_;
public:
    void push(T x) { data_.push_back(std::move(x)); }
    T pop()        { T t = std::move(data_.back()); data_.pop_back(); return t; }
};

Stack<int> s1;
Stack<std::string> s2;

Fonctions membres définies en dehors de la classe

Les définitions situées en dehors de la classe doivent comporter le préfixe de modèle pour chaque membre.

template <typename T>
class Stack {
public:
    void push(T x);
};

template <typename T>
void Stack<T>::push(T x) {
    data_.push_back(std::move(x));
}

Arguments de modèle par défaut

Comme pour les arguments de fonction par défaut. Ils sont utilisés lorsque l’appelant n’en spécifie pas.

template <typename T = int>
class Box {
    T value;
};

Box<> b;       // T is int

Déduction des arguments de modèle

Le compilateur déduit souvent les arguments de modèle à partir de l’appel.

template <typename T>
void print(T x) { std::cout << x; }

print(42);          // T deduced as int
print("hello");    // T deduced as const char*
print<double>(3);   // explicit

Déduction des arguments des modèles de classes (C++17)

C++17 vous permet d’omettre les arguments des modèles de classes lorsqu’ils peuvent être déduits du constructeur.

std::pair p(1, 2.5);            // pair<int, double>
std::vector v{1, 2, 3};         // vector<int>

Recherche en deux phases

Les modèles font l’objet d’une recherche en deux phases : lors de la définition (noms non dépendants), puis lors de l’instanciation (noms dépendants). Cela permet de détecter de nombreuses erreurs dès la définition.

Messages d’erreur

Les erreurs de modèle peuvent être intimidantes. Lisez-les de bas en haut, concentrez-vous sur l’emplacement dans le code source et utilisez les concepts C++20 pour améliorer les diagnostics.

Vérification rapide

Quelle fonctionnalité permet de compiler std::vector v{1, 2, 3}; sans spécifier std::vector<int> ?

Récapitulatif

Les modèles génèrent du code spécifique aux types au moment de la compilation. Définissez des modèles de fonctions et de classes avec template <typename T>. Le compilateur déduit les arguments lorsque c’est possible ; spécifiez-les explicitement lorsque c’est nécessaire.

Questions Fréquemment Posées

La leçon « Modèles de fonctions et de classes : révision » est-elle gratuite ?

Oui — le texte complet de « Modèles de fonctions et de classes : révision » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèles de fonctions et de classes : révision » ?

Écrire des fonctions et des classes génériques avec une syntaxe de modèle correcte Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Modèles de fonctions et de classes : révision » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Modèles de fonctions et de classes : révision
  2. Spécialisation partielle et complète des modèles
  3. Modèles variadiques et paquets de paramètres
  4. Fonctions constexpr et if constexpr
← Retour à C++ Academy