Formation C++ débutant

Leçon 1 • Comprendre le C++ et ses utilisations

Le C++ est un langage compilé et typé statiquement utilisé dans les systèmes, les jeux et les logiciels embarqués. Ce contexte motive les choix de la chaîne d'outils effectués tout au long du chapitre.

Leçon 2 • Choix et configuration d'un IDE

Un IDE accélère le développement avec l'édition, la construction et le débogage dans un seul outil. Les apprenants configurent VS Code ou Code::Blocks pour des projets C++.

Leçon 3 • Comprendre les erreurs et les avertissements de construction

Les diagnostics du compilateur sont la première boucle de rétroaction dans le développement C++. Les apprenants apprennent à lire les messages d'erreur et à corriger les erreurs de configuration courantes.

Leçon 4 • Écrire et compiler Hello World

Le programme classique Hello World introduit la structure minimale d'un fichier source C++. Les apprenants le compilent et l'exécutent pour confirmer que toute la chaîne d'outils fonctionne.

Leçon 1 • Opérateurs arithmétiques et d'affectation

Les opérateurs arithmétiques effectuent des calculs sur les types numériques ; les opérateurs d'affectation mettent à jour les variables de manière concise. Les apprenants écrivent des expressions combinant les deux groupes d'opérateurs.

Leçon 2 • Types de données fondamentaux

C++ fournit des types entiers, virgule flottante, caractère et booléen avec des tailles définies. Les apprenants choisissent les types appropriés pour les exigences de données données.

Leçon 3 • Conversions et transtypages de types

Les conversions implicites peuvent entraîner une perte de données ; les conversions explicites clarifient l'intention. Les apprenants identifient les conversions dangereuses et appliquent correctement static_cast.

Leçon 4 • Constantes et littéraux

Les constantes empêchent la modification accidentelle de valeurs fixes. Les apprenants utilisent const, constexpr et des littéraux typés pour exprimer clairement des données immuables.

Leçon 1 • Lecture de lignes de texte complètes

std::getline lit une ligne entière incluant les espaces, contrairement à l'opérateur d'extraction. Les apprenants combinent correctement getline avec cin pour éviter les pièges courants.

Leçon 2 • Introduction à std::string

std::string est la classe standard pour les données textuelles en C++. Les apprenants créent, affectent et concatènent des chaînes à l'aide de ses fonctions membres.

Leçon 3 • Sortie console avec std::cout

std::cout envoie du texte formaté au terminal à l'aide de l'opérateur d'insertion. Les apprenants contrôlent l'espacement, les sauts de ligne et le formatage numérique dans la sortie.

Leçon 4 • Lecture d'entrée avec std::cin

std::cin lit des jetons délimités par des espaces depuis le clavier dans des variables. Les apprenants gèrent des scénarios d'entrée simples et détectent les échecs d'entrée de base.

Leçon 1 • Boucles for et while

Les boucles for itèrent un nombre connu de fois ; les boucles while répètent tant qu'une condition est vraie. Les apprenants choisissent le type de boucle approprié et écrivent des conditions de boucle correctes.

Leçon 2 • Expressions booléennes et comparaisons

Les conditions sont construites à partir d'opérateurs relationnels et logiques qui s'évaluent à true ou false. Les apprenants construisent des conditions composées pour des scénarios de décision réalistes.

Leçon 3 • do-while, break et continue

do-while garantit au moins une exécution ; break et continue modifient le flux de la boucle en cours d'itération. Les apprenants appliquent ces constructions à la validation d'entrée et aux tâches de recherche.

Leçon 4 • Instructions if, else if et else

Les chaînes if-else sélectionnent un chemin de code parmi plusieurs alternatives en fonction des conditions. Les apprenants structurent clairement la logique à branches multiples et évitent les problèmes de else pendant.

Leçon 1 • Valeurs de retour et sorties multiples

Les fonctions communiquent les résultats via des valeurs de retour ou des paramètres de sortie. Les apprenants renvoient des données structurées et utilisent des paramètres de référence pour des sorties multiples.

Leçon 2 • Définition et appel de fonctions

Une fonction encapsule un bloc nommé de logique réutilisable. Les apprenants écrivent des définitions de fonctions, des déclarations et des sites d'appel avec des types d'arguments correspondants.

Leçon 3 • Surcharge de fonctions

La surcharge permet à plusieurs fonctions de partager un nom lorsque leurs listes de paramètres diffèrent. Les apprenants définissent des fonctions surchargées et comprennent comment le compilateur résout les appels.

Leçon 4 • Paramètres et arguments

Les paramètres définissent les entrées qu'une fonction attend ; les arguments fournissent les valeurs réelles. Les apprenants distinguent le passage par valeur du passage par référence et choisissent de manière appropriée.

Leçon 1 • Tri et recherche dans les collections

La bibliothèque standard fournit des algorithmes de tri et de recherche efficaces pour les vecteurs. Les apprenants appliquent std::sort et std::binary_search avec des comparateurs par défaut et personnalisés.

Leçon 2 • Introduction à std::array et std::string

std::array encapsule un tableau brut de taille fixe avec une interface plus sûre et compatible STL. Les apprenants comparent std::array, les tableaux bruts et les vecteurs pour choisir le bon conteneur.

Leçon 3 • Opérations courantes sur les vecteurs

Les vecteurs prennent en charge l'insertion, la suppression et la recherche au-delà du simple push et pop. Les apprenants utilisent insert, erase et find pour manipuler précisément le contenu des vecteurs.

Leçon 4 • Tableaux bruts en C++

Les tableaux bruts stockent des séquences de taille fixe d'un seul type dans une mémoire contiguë. Les apprenants déclarent, initialisent et accèdent aux éléments du tableau tout en respectant les limites.

Leçon 1 • Introduction aux pointeurs intelligents

Les pointeurs intelligents automatisent la gestion de la mémoire et évitent les fuites. Les apprenants utilisent std::unique_ptr pour la propriété exclusive et std::shared_ptr pour les scénarios de propriété partagée.

Leçon 2 • Déréférencement et arithmétique de pointeurs

Déréférencer un pointeur accède à la valeur à son adresse stockée. Les apprenants effectuent une arithmétique de pointeurs pour parcourir les tableaux et comprennent la relation entre les tableaux et les pointeurs.

Leçon 3 • Références vs pointeurs

Les références sont des alias qui ne peuvent pas être nuls ou réaffectés ; les pointeurs sont flexibles mais plus risqués. Les apprenants choisissent entre les références et les pointeurs en fonction des besoins de propriété et de nullabilité.

Leçon 4 • Allocation de mémoire dynamique

new et delete allouent et libèrent la mémoire du tas à l'exécution. Les apprenants gèrent des objets simples et des tableaux sur le tas et identifient les fuites mémoire.

Leçon 1 • Héritage de base et polymorphisme

L'héritage permet à une classe dérivée de réutiliser et d'étendre une classe de base. Les apprenants créent une hiérarchie de classes simple et appellent des fonctions virtuelles surchargées via des pointeurs de base.

Leçon 2 • Définition et utilisation de structures

Les structures regroupent des champs de données connexes sous un seul nom. Les apprenants définissent des structures, créent des instances et accèdent aux membres pour représenter des données composées.

Leçon 3 • Fonctions membres et méthodes

Les fonctions membres opèrent sur les données d'un objet et définissent son comportement. Les apprenants implémentent des fonctions membres const et comprennent comment les méthodes accèdent aux données privées.

Leçon 4 • Introduction aux classes et à l'encapsulation

Les classes ajoutent un contrôle d'accès pour regrouper les données et le comportement. Les apprenants utilisent public et private pour appliquer l'encapsulation et exposer des interfaces sûres.