Cours C++ Complet 🚀

Les 16 chapitres essentiels pour apprendre le C++ — de la syntaxe de base au C++ moderne (C++20/23), avec exceptions, multithreading, fichiers, et 100+ exemples de code

Chapitres

100+

Exemples de code

C++20/23

Standard

A1→C2

Niveaux

📋 Sommaire — Cours C++ complet

1. Introduction et premier programme
9. La STL : Conteneurs
2. Variables et types de données
10. La STL : Algorithmes et lambdas
3. Opérateurs et flux I/O
11. Gestion mémoire moderne
4. Structures conditionnelles
12. Exceptions et gestion d'erreurs
5. Boucles et tableaux
13. Fichiers et flux (fstream)
6. Fonctions, enums et namespaces
14. Multithreading (std::thread)
7. POO : Classes et objets
15. C++ moderne (17/20/23)
8. Héritage, polymorphisme et templates
16. Bonnes pratiques et outils

📚 Voir aussi nos autres cours

🏠 Hub Programmation
🔧 C
🦀 Rust
☕ Java
🐹 Go
🐍 Python
💜 C#
🏛️ POO

CHAPITRE 01

Introduction et premier programme

🚀 Hello World

#include

int main()

// Avec using namespace (plus concis mais déconseillé dans les headers)
#include
using namespace std;

int main()

C++ vs C : C++ est un superset du C. Il ajoute la POO, les templates, la STL, les exceptions, les smart pointers, et bien plus. Tout code C valide est (presque) du C++ valide, mais le C++ moderne évite les patterns C (printf → cout, malloc → new/smart pointers).

⚙️ Compiler et exécuter

# Compiler avec g++
g++ -std=c++20 -Wall -Wextra hello.cpp -o hello# Exécuter
./hello

# Avec clang++
clang++ -std=c++20 -Wall hello.cpp -o hello

# Avec CMake (projets multi-fichiers — standard en C++)
cmake -B build -DCMAKE_CXX_STANDARD=20
cmake –build build

🏗️ C++ en résumé

Caractéristique	C++
Typage	Statique et fort
Paradigme	Multi-paradigme : POO + procédural + fonctionnel + générique
Compilation	Compilé en code machine natif (très rapide)
Mémoire	Gestion manuelle (mais smart pointers en moderne)
Usage	Jeux (Unreal Engine), systèmes, finance, embarqué, navigateurs (Chrome), IA/ML
Convention	PascalCase (classes), camelCase ou snake_case (variables/fonctions)
Standard actuel	C++23 (2024), C++26 en cours de développement

🧠 Quiz

Quelle est la différence principale entre C et C++ ?

Le C++ ajoute la programmation orientée objet (classes, héritage, polymorphisme), les templates (generics), la STL (conteneurs/algorithmes), et la gestion mémoire automatique (smart pointers).

CHAPITRE 02

Variables et types de données

📦 Types fondamentaux

#include
#includeint main()

📝 std::string — méthodes essentielles

std::string s = « Hello World »;

s.length() // 11 (ou .size())
s.empty() // false
s.substr(0, 5) // « Hello »
s.find(« World ») // 6 (index, ou string::npos si pas trouvé)
s.replace(6, 5, « C++ ») // « Hello C++ »
s.append( » ! ») // « Hello C++ ! »
s[0] // 'H'
s.front() // 'H'
s.back() // '!'
s.starts_with(« He ») // true (C++20)
s.contains(« C++ ») // true (C++23)

// Comparaison avec == (pas besoin de strcmp !)
if (s == « Hello C++ ! »)

// Conversion
std::string n = std::to_string(42); // « 42 »
int val = std::stoi(« 42 »); // 42
double dval = std::stod(« 3.14 »); // 3.14

Toujours std::string en C++. Contrairement au C (char[]), std::string gère automatiquement la mémoire, supporte la concaténation avec +, la comparaison avec ==, et ne risque pas le buffer overflow.

🔄 Références

// Référence = alias pour une variable existante
int x = 10;
int& ref = x; // ref EST x (même adresse mémoire)
ref = 20; // x vaut maintenant 20// Référence const — lecture seule
const int& cref = x;
cref = 30; // ❌ Erreur — const

// Différences pointeur vs référence :
// Pointeur : peut être NULL, peut changer de cible, syntaxe * et &
// Référence : JAMAIS null, liée à vie, syntaxe transparente

🧠 Quiz

Différence entre const et constexpr ?

const = non modifiable à l'exécution (peut être initialisé avec une valeur runtime). constexpr = calculé à la compilation (doit être une expression constante). constexpr est plus strict et plus optimisé.

CHAPITRE 03

Opérateurs et flux I/O

🖨️ Entrée / Sortie avec iostream

#include
#include
#include

// C++20// Sortie — cout (chaînable avec <<)
std::cout << « Nom: « << nom << « , Age: « << age << « n »;

// std::format (C++20) — comme f-string Python
std::cout << std::format(« Nom: , Age: n », nom, age);
std::cout << std::format(« Pi = n », 3.14159); // Pi = 3.14

// std::print (C++23) — encore plus simple
std::print(« Nom: , Age: n », nom, age);

// Entrée — cin
int age;
std::cout << « Votre âge : « ;
std::cin >> age;

// Lire une ligne entière (avec espaces)
std::string ligne;
std::getline(std::cin, ligne);

⚖️ Opérateurs spécifiques C++

// Tous les opérateurs C + :

// Scope resolution (::)
std::cout // cout dans le namespace std
MyClass::method // méthode de MyClass

// new / delete (allocation dynamique C++)
int* p = new int(42);
delete p;

int* arr = new int[10];
delete[] arr; // ⚠️ delete[] pour les tableaux

// Casts C++ (plus sûrs que le cast C)
static_cast<double>(7) / 2 // 3.5
dynamic_cast<Derived*>(basePtr) // Cast polymorphique (vérifié)

En C++ moderne, n'utilisez JAMAIS new/delete directement. Utilisez std::make_unique et std::make_shared (chapitre 11). Le new/delete nu est la source principale de memory leaks.

CHAPITRE 04

Structures conditionnelles

🔀 if, switch, if constexpr

// if / else — identique au C
if (age < 18) else // if avec initialisation (C++17)
if (auto it = map.find(key); it != map.end())

// switch — int, char, enum
switch (choix)

// if constexpr (C++17) — évalué à la compilation
template<typename T>
auto stringify(T value)

CHAPITRE 05

Boucles et tableaux

🔁 for, range-based for, while

// for classique
for (int i = 0; i < 5; i++) // Range-based for (C++11) — le plus utilisé
std::vector<int> nums = ;
for (int n : nums)

// Par référence const (pas de copie, pas de modification)
for (const auto& n : nums)

// Par référence (pour modifier)
for (auto& n : nums)

📊 std::array et std::vector

#include
#include// std::array — taille fixe (remplacement du C array)
std::array<int, 5> arr = ;
arr.size() // 5
arr[0] // 10
arr.at(10) // ✅ Lève une exception si hors limites

// std::vector — taille dynamique (LE plus utilisé)
std::vector<int> vec = ;
vec.push_back(4); // Ajouter à la fin
vec.pop_back(); // Retirer le dernier
vec.size() // 3
vec.empty() // false
vec.front() // 1
vec.back() // 3
vec.clear() // Vider
vec.erase(vec.begin()); // Supprimer le premier

Règle d'or : En C++ moderne, utilisez std::vector par défaut. N'utilisez les C arrays int arr[] que pour de l'embarqué ou du code très contraint. std::array pour les tailles fixes connues à la compilation.

🧠 Quiz

Pourquoi utiliser const auto& dans un range-based for ?

const = on ne modifie pas l'élément. auto = le compilateur déduit le type. & = référence (évite de copier chaque élément). C'est le pattern par défaut pour la lecture.

CHAPITRE 06

Fonctions, enums et namespaces

⚡ Fonctions C++ : paramètres, surcharge, valeurs par défaut

// Passage par valeur (copie) — petits types
int square(int x) // Passage par const ref — gros objets (évite la copie)
void print(const std::string& s)

// Passage par référence — pour modifier
void increment(int& x)

// Valeurs par défaut
void greet(std::string name = « World »)

// Surcharge (overloading) — même nom, types différents
int add(int a, int b)
double add(double a, double b)

// constexpr function — évaluée à la compilation
constexpr int factorial(int n)
constexpr int f5 = factorial(5); // 120, calculé à la compilation

Règle des paramètres : petits types (int, double) → par valeur. Gros objets (string, vector, classes) → par const référence. Quand on veut modifier → par référence.

🏷️ enum class (C++11) — type-safe

// ❌ Ancien enum C — polluent le scope
enum Color ;// ✅ enum class (C++11) — scoped, type-safe
enum class Color ;
enum class HttpStatus : int ;

Color c = Color::Red;
// int x = c; // ❌ Pas de conversion implicite — type-safe !

switch (c)

📦 Namespaces

namespace math
double a = math::area(5.0);// Nested namespaces (C++17)
namespace company::project::module { void init() }

Jamais using namespace std; dans un header (.h). Cela pollue l'espace de noms de tous les fichiers qui incluent le header. Dans un .cpp, c'est toléré mais déconseillé en production.

CHAPITRE 07

POO : Classes et objets

🏛️ Définir une classe

class Person {
private:
std::string name_;
int age_;public:
// Constructeur
Person(std::string name, int age)
: name_{std::move(name)}, age_{age} // Liste d'initialisation

// Getters
const std::string& name() const { return name_; }
int age() const { return age_; }

// Setter
void set_age(int age) { age_ = age; }

// Méthode
std::string greet() const {
return « Bonjour, je suis « + name_;
}

// Surcharge de l'opérateur <<
friend std::ostream& operator<<(std::ostream& os, const Person& p) {
os << p.name_ << » (« << p.age_ << » ans) »;
return os;
}
};

Person alice; // Uniform initialization
std::cout << alice << std::endl;

const après une méthode signifie que la méthode ne modifie pas l'objet. Toutes les méthodes qui ne modifient pas l'état doivent être const. C'est une convention fondamentale en C++.

⚡ struct vs class et Rule of Five

// struct = class avec public par défaut
struct Point ;// Rule of Five — si vous définissez l'un, définissez les 5 :
class Resource ;

// Rule of Zero (préféré) — si vous n'avez pas de ressource brute,
// ne définissez AUCUN des 5 et laissez le compilateur tout gérer

🧠 Quiz

Différence entre struct et class en C++ ?

Seule différence : struct = membres public par défaut. class = membres private par défaut. En pratique, struct est utilisé pour les données simples, class pour les objets avec logique.

CHAPITRE 08

Héritage, polymorphisme et templates

🔗 Héritage et virtual

class Animal {
protected:
std::string name_;
public:
Animal(std::string name) : name_{std::move(name)} // virtual = peut être surchargée (nécessaire pour le polymorphisme)
virtual std::string speak() const {
return name_ + » fait du bruit »;
}

// Destructeur VIRTUEL — obligatoire si héritage
virtual ~Animal() = default;
};

class Dog : public Animal {
public:
Dog(std::string name) : Animal{std::move(name)}

// override — vérifie à la compilation que la méthode parent existe
std::string speak() const override {
return name_ + » : Wouf ! »;
}
};

// Polymorphisme — fonctionne avec pointeurs/références
std::unique_ptr<Animal> a = std::make_unique<Dog>(« Rex »);
std::cout << a->speak(); // « Rex : Wouf ! »

Destructeur virtuel OBLIGATOIRE sur toute classe de base. Sans lui, delete sur un pointeur de base ne détruira pas correctement l'objet dérivé (memory leak/undefined behavior).

⛔ final et pure virtual

// Classe abstraite — ne peut pas être instanciée
class Shape ;class Circle final : public Shape { // final = personne ne peut en hériter
double radius_;
public:
Circle(double r) : radius_{r}
double area() const override { return 3.14159 * radius_ * radius_; }
};

🔄 Function templates

// Template = code générique qui fonctionne avec tout type
template<typename T>
T max_val(T a, T b) max_val(3, 7); // T = int → retourne 7
max_val(3.14, 2.71); // T = double → retourne 3.14
max_valstring>(« a », « b »); // Explicit

// Concepts (C++20) — contraindre le type
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<Numeric T>
T add(T a, T b)

add(3, 4); // ✅
add(« a », « b »); // ❌ string n'est pas Numeric

📦 Class templates

template<typename T>
class Stack ;Stack<int> intStack;
intStack.push(42);

Stackstring> strStack;
strStack.push(« hello »);

Concepts (C++20) remplacent SFINAE et les static_assert obscurs. Ils donnent des messages d'erreur clairs quand un type ne remplit pas le contrat. Similaire aux contraintes generics de TypeScript.

CHAPITRE 09

La STL : Conteneurs

📋 Les conteneurs principaux

Conteneur	Description	Accès
vector	Tableau dynamique (le plus utilisé)	O(1) par index
array	Tableau fixe	O(1) par index
deque	File à double extrémité	O(1) début/fin
list	Liste doublement chaînée	O(n) accès, O(1) insertion
set	Éléments uniques, triés	O(log n)
unordered_set	Éléments uniques, hash	O(1) moyen
map	Clé/valeur, triées par clé	O(log n)
unordered_map	Clé/valeur, hash	O(1) moyen
stack	LIFO	O(1) top
queue	FIFO	O(1) front/back

🔧 map et unordered_map

#include

std::unordered_mapstring, int> ages = {
,
{« Bob », 30},
};

// Accès
ages[« Alice »] // 25 (⚠️ crée une entrée si clé absente)
ages.at(« Alice ») // 25 (lance exception si clé absente)
ages.count(« Eve ») // 0 (n'existe pas)
ages.contains(« Bob ») // true (C++20)

// Itérer
for (const auto& [nom, age] : ages)

// Insérer / supprimer
ages.insert();
ages.erase(« Bob »);

🧠 Quiz

Quand utiliser map vs unordered_map ?

unordered_map = O(1) moyen, plus rapide pour la plupart des cas. map = O(log n) mais éléments triés par clé. Utilisez map uniquement si l'ordre des clés importe.

CHAPITRE 10

La STL : Algorithmes et lambdas

⚡ Expressions lambda (C++11)

// Lambda = fonction anonyme inline
// [capture](params) -> retour auto add = [](int a, int b) ;
add(3, 4); // 7

// Captures
int x = 10;
auto f1 = [x]() ; // Copie de x
auto f2 = [&x]() ; // Référence vers x
auto f3 = [=]() ; // Copie de tout
auto f4 = [&]() ; // Référence à tout

// Generic lambda (C++14)
auto print = [](const auto& val) ;

🔧 Algorithmes STL

#include
#include
#include // C++20std::vector<int> v = ;

// Trier
std::sort(v.begin(), v.end()); //
std::sort(v.begin(), v.end(), std::greater<>()); // Décroissant

// Chercher
auto it = std::find(v.begin(), v.end(), 8);
bool found = std::binary_search(v.begin(), v.end(), 5); // O(log n)

// Transformer
std::vector<int> doubled;
std::transform(v.begin(), v.end(), std::back_inserter(doubled),[](int n) );

// Filtrer (C++20 Ranges)
auto evens = v | std::views::filter([](int n) );

// Chaînage Ranges (C++20)
auto result = v
| std::views::filter([](int n) )
| std::views::transform([](int n) );

// Autres
std::count_if(v.begin(), v.end(), [](int n) );
std::accumulate(v.begin(), v.end(), 0); // Somme
std::min_element(v.begin(), v.end());
std::max_element(v.begin(), v.end());
std::any_of(v.begin(), v.end(), [](int n) );
std::all_of(v.begin(), v.end(), [](int n) );

C++20 Ranges = la révolution. Chaînez les opérations avec le pipe |, comme les Streams Java ou LINQ C#. Plus besoin de begin()/end() partout.

CHAPITRE 11

Gestion mémoire moderne

🛡️ Smart Pointers (C++11)

#include

// unique_ptr — propriétaire UNIQUE (pas de copie, move uniquement)
auto ptr = std::make_unique<Person>(« Alice », 25);
ptr->greet(); // Utilisation identique à un pointeur brut
// Détruit automatiquement quand ptr sort du scope ✅

// Transférer la propriété
auto ptr2 = std::move(ptr); // ptr est maintenant nullptr

// shared_ptr — propriété partagée (compteur de références)
auto sp1 = std::make_shared<Person>(« Bob », 30);
auto sp2 = sp1; // 2 shared_ptr pointent vers le même objet
sp1.use_count() // 2
// Détruit quand le dernier shared_ptr est détruit

// weak_ptr — observe sans posséder (évite les cycles)
std::weak_ptr<Person> wp = sp1;
if (auto locked = wp.lock())

Règle : jamais de new/delete nu. Utilisez make_unique (99% des cas) ou make_shared (propriété partagée). Les smart pointers garantissent la libération automatique et éliminent les memory leaks.

🔄 Move semantics et RAII

// RAII = Resource Acquisition Is Initialization
// = les ressources sont liées à la durée de vie d'un objet// Le destructeur nettoie automatiquement
{
std::vector<int> v = ; // Allocation
// … utilisation de v …
} // v détruit automatiquement, mémoire libérée ✅

// Move semantics — transférer au lieu de copier
std::vector<int> createBigVector()

std::vector<int> data = createBigVector(); // Move, O(1)

🧠 Quiz

Quand utiliser unique_ptr vs shared_ptr ?

unique_ptr = quand un seul propriétaire (99% des cas, zéro overhead). shared_ptr = quand plusieurs objets doivent partager la même ressource (compteur de références, petit overhead).

CHAPITRE 12

Exceptions et gestion d'erreurs

🚨 try / catch / throw

#include

double divide(double a, double b)

try catch (const std::invalid_argument& e) catch (const std::exception& e) catch (…)

📋 Exceptions standard et bonnes pratiques

Exception	Usage
std::runtime_error	Erreur à l'exécution (fichier introuvable, réseau…)
std::invalid_argument	Argument invalide passé à une fonction
std::out_of_range	Index hors limites (vector::at())
std::bad_alloc	Allocation mémoire échouée

noexcept : marquez les fonctions qui ne lancent jamais d'exception avec noexcept. Le compilateur optimise mieux, et les conteneurs STL en profitent (move constructors noexcept utilisés par vector lors du redimensionnement).

Exceptions vs optional : pour les erreurs « attendues » (fichier absent, entrée invalide), std::optional ou std::expected (C++23) sont souvent préférés car ils n'ont pas le coût du déroulement de pile.

CHAPITRE 13

Fichiers et flux (fstream)

📄 Lire et écrire des fichiers

#include
#include// Écrire dans un fichier
std::ofstream out(« data.txt »);
if (out.is_open()) // Fichier fermé automatiquement (RAII) ✅

// Lire ligne par ligne
std::ifstream in(« data.txt »);
std::string line;
while (std::getline(in, line))

// Lire tout le fichier d'un coup
std::ifstream file(« data.txt »);
std::string content(
(std::istreambuf_iterator<char>(file)),
std::istreambuf_iterator<char>()
);

// std::filesystem (C++17) — manipuler chemins et fichiers
#include
namespace fs = std::filesystem;

fs::exists(« data.txt »); // true
fs::file_size(« data.txt »); // taille en octets
fs::remove(« old.txt »); // supprimer
for (auto& entry : fs::directory_iterator(« . »))

RAII pour les fichiers : pas besoin de .close() explicite. Le destructeur de fstream ferme automatiquement le fichier quand l'objet sort du scope. C'est la force du C++ moderne.

CHAPITRE 14

Multithreading (std::thread)

🧵 Threads et synchronisation

#include
#include
#include// Créer un thread
void work(int id)

std::thread t1(work, 1);
std::thread t2(work, 2);
t1.join(); // Attendre la fin
t2.join();

// Mutex — protéger une ressource partagée
std::mutex mtx;
int counter = 0;

void safe_increment() // lock libéré automatiquement

// async — lancer une tâche et récupérer le résultat
auto future = std::async(std::launch::async, []() );
int result = future.get(); // Bloque jusqu'au résultat

Toujours utiliser std::lock_guard ou std::scoped_lock (C++17) pour les mutex. Ne jamais faire mtx.lock() / mtx.unlock() manuellement — risque de deadlock si une exception est lancée entre les deux.

std::jthread (C++20) est une version améliorée de thread qui appelle .join() automatiquement dans son destructeur (RAII). Préférez jthread quand votre compilateur le supporte.

CHAPITRE 15

C++ moderne (17/20/23)

⚡ C++17 Features

// Structured bindings
auto [nom, age] = std::make_pair(« Alice », 25);
for (const auto& [key, val] : myMap) // std::optional — valeur qui peut être absente
std::optional<int> findAge(const std::string& name)
auto age = findAge(« Alice »);
if (age.has_value()) std::cout << *age;
int val = age.value_or(0);

// std::variant — union type-safe
std::variant<int, std::string> v = 42;
v = « hello »;
if (std::holds_alternativestring>(v))

// if constexpr — branches évaluées à la compilation
// std::filesystem — manipuler fichiers/dossiers
// std::string_view — référence non-possédante vers une string

🚀 C++20 Features

// Ranges — chaînage fonctionnel
auto result = nums
| std::views::filter([](int n) )
| std::views::transform([](int n) )
| std::views::take(5);// Concepts — contraintes lisibles
templateT>
T gcd(T a, T b)

// Three-way comparison (spaceship operator)
auto r = 5 <=> 3; // std::strong_ordering::greater

// std::format — formatage type-safe
std::cout << std::format(« Pi = », 3.14159);

// Coroutines (co_await, co_yield, co_return)
// Modules (import std; — remplace #include)
// Designated initializers
Point p = ;
// std::jthread — thread avec RAII (auto-join)

🆕 C++23 Features

// std::print — remplacement de cout (enfin !)
std::print(« Nom: , Age: n », « Alice », 25);
std::println(« Avec saut de ligne automatique »);// std::expected — gestion d'erreur sans exception
std::expected<int, std::string> parse_int(const std::string& s)
auto r = parse_int(« 42 »);
if (r.has_value()) std::cout << *r;

// string::contains (enfin !)
std::string s = « Hello C++23 »;
s.contains(« C++ »); // true

// std::flat_map — map basée sur des vecteurs triés (plus rapide)
// Deducing this — simplifie les patterns CRTP
// std::generator — générateur coroutine simple
// Multidimensional subscript operator: matrix[x, y]
// if consteval — tester si on est évalué à la compilation

std::expected (C++23) est l'alternative moderne aux exceptions pour les erreurs « attendues ». Comme Result en Rust. Pas de coût de déroulement de pile, et le type d'erreur est explicite dans la signature.

🧠 Quiz

Que remplace std::optional ?

Il remplace le pattern « retourner -1 ou nullptr pour dire absent ». optional exprime explicitement qu'une valeur peut être présente ou absente, de façon type-safe.

Qu'est-ce que RAII ?

Resource Acquisition Is Initialization. Les ressources (mémoire, fichiers, connexions) sont liées à la durée de vie d'un objet. Le destructeur libère automatiquement quand l'objet sort du scope. C'est LE principe fondamental du C++ moderne.

CHAPITRE 16

Bonnes pratiques et outils C++

✅ Bonnes pratiques C++ moderne

✅ À FAIRE
• -std=c++20 -Wall -Wextra
• auto quand le type est évident
• const et constexpr partout
• make_unique / make_shared
• vector par défaut
• string_view pour les paramètres
• Ranges pour les algorithmes
• override / final explicit
• RAII (pas de resource leak)
• enum class au lieu de enum
• noexcept sur les move constructors

❌ À ÉVITER
• new / delete nus
• C arrays int arr[]
• using namespace std dans les headers
• printf / scanf (utiliser cout / format)
• C-style casts (int)x
• malloc / free (c'est du C)
• Macros pour les constantes (#define)
• Retourner des raw pointers
• Variables non initialisées
• mtx.lock() sans lock_guard

🔧 Outils essentiels pour le C++

Outil	Usage
CMake	Système de build standard — CMakeLists.txt
clang-tidy	Linter — détecte les mauvaises pratiques
AddressSanitizer	-fsanitize=address — détecte les accès mémoire invalides
Valgrind	Détecte les memory leaks à l'exécution
clang-format	Formatage automatique du code
Conan / vcpkg	Gestionnaires de paquets C++
Compiler Explorer	godbolt.org — voir l'assembleur généré en ligne

🧠 Quiz

Que remplace std::optional ?

Il remplace le pattern « retourner -1 ou nullptr pour dire absent ». optional exprime explicitement qu'une valeur peut être présente ou absente, de façon type-safe.

Qu'est-ce que RAII ?

📚 Continuer à apprendre

🏠 Hub Programmation
🔧 Cours C
🦀 Cours Rust
☕ Cours Java
🐹 Cours Go
🐍 Cours Python
💜 Cours C#
🏛️ Cours POO
🧮 Algorithmes
📊 Structures de données
✨ Clean Code

Cours C++ Complet — Des bases au C++ moderne (C++20/23)

Référence : cppreference.com | isocpp.org