Templates

• Permettre de paramétrer une classe, une fonction
• À la compilation, substituer le type template par un type réel
• Voir ça comme du copier/coller du code fait par le compilateur

Déclaration et d'utilisation d'un template en C++ 20

Voici un exemple simple et commenté de déclaration et d'utilisation d'un template en C++ 20 :

#include <iostream>
#include <string>
#include <vector>
#include <concepts> // Pour les concepts C++20

// Template de fonction simple
// Cette fonction accepte n'importe quel type T et renvoie sa valeur doublée
template <typename T>
T doubler(T valeur) {
    return valeur * 2; // Multiplie la valeur par 2
}

// Template avec concept C++20
// Cette fonction n'accepte que des types numériques
template <typename T>
requires std::is_arithmetic_v<T> // Contrainte: T doit être un type arithmétique
T ajouter(T a, T b) {
    return a + b;
}

// Template de classe
// Cette classe permet de stocker et manipuler un tableau de n'importe quel type
template <typename T>
class Conteneur {
private:
    std::vector<T> elements; // Stockage interne des éléments

public:
    // Ajoute un élément au conteneur
    void ajouter(const T& element) {
        elements.push_back(element);
    }

    // Récupère un élément à l'index spécifié
    T obtenir(size_t index) const {
        if (index < elements.size()) {
            return elements[index];
        }
        throw std::out_of_range("Index hors limites");
    }

    // Affiche tous les éléments du conteneur
    void afficher() const {
        for (const auto& element : elements) {
            std::cout << element << " ";
        }
        std::cout << std::endl;
    }

    // Renvoie le nombre d'éléments dans le conteneur
    size_t taille() const {
        return elements.size();
    }
};

// Exemple d'utilisation avec spécialisation de template
// Cette spécialisation traite spécifiquement les chaînes de caractères
template <>
void Conteneur<std::string>::afficher() const {
    std::cout << "Conteneur de chaînes: ";
    for (const auto& element : elements) {
        std::cout << "\\\\"" << element << "\\\\" ";
    }
    std::cout << std::endl;
}

int main() {
    // Utilisation du template de fonction
    std::cout << "Double de 5: " << doubler(5) << std::endl;
    std::cout << "Double de 3.14: " << doubler(3.14) << std::endl;

    // Utilisation du template avec concept
    std::cout << "Somme de 10 + 20: " << ajouter(10, 20) << std::endl;
    std::cout << "Somme de 1.5 + 2.5: " << ajouter(1.5, 2.5) << std::endl;

    // Utilisation du template de classe avec des entiers
    Conteneur<int> conteneurEntiers;
    conteneurEntiers.ajouter(10);
    conteneurEntiers.ajouter(20);
    conteneurEntiers.ajouter(30);
    std::cout << "Conteneur d'entiers: ";
    conteneurEntiers.afficher();

    // Utilisation du template de classe avec des chaînes (spécialisation)
    Conteneur<std::string> conteneurChaines;
    conteneurChaines.ajouter("Bonjour");
    conteneurChaines.ajouter("C++");
    conteneurChaines.ajouter("Templates");
    conteneurChaines.afficher(); // Utilise la version spécialisée

    return 0;
}

Explications

1. Template de fonction simple (doubler) :
   • Accepte n'importe quel type T et renvoie sa valeur multipliée par 2
   • Fonctionne avec tous les types qui supportent l'opérateur
2. Template avec concept C++20 (ajouter) :
   • Utilise la fonctionnalité requires de C++20 pour contraindre les types acceptés
   • Ne fonctionne qu'avec des types arithmétiques (entiers, flottants)
3. Template de classe (Conteneur) :
   • Définit une classe générique qui peut stocker des éléments de n'importe quel type
   • Implémente des méthodes basiques pour manipuler ces éléments
4. Spécialisation de template :
   • Fournit une implémentation spécifique de la méthode afficher() pour le type std::string
   • Permet de personnaliser le comportement pour certains types
5. Utilisation dans main() :
   • Montre comment instancier et utiliser les templates avec différents types

Exceptions

• Syntaxe similaire à java
• Définir vos exceptions à partir de std::exception

Les pointeurs intelligents en C++ 20

Les pointeurs intelligents (smart pointers) sont une fonctionnalité importante du C++ moderne qui aide à gérer la mémoire de manière plus sûre et efficace. Voici une explication simple de ce concept :

Qu'est-ce qu'un pointeur intelligent ?

Un pointeur intelligent est un objet qui se comporte comme un pointeur traditionnel mais qui gère automatiquement la durée de vie de l'objet qu'il pointe. Contrairement aux pointeurs bruts (raw pointers), les pointeurs intelligents libèrent automatiquement la mémoire lorsqu'ils ne sont plus utilisés.