Cours de C++ débutant

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

C++ est un langage compilé 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 tout au long du chapitre.

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

Un IDE accélère le développement en regroupant l'édition, la compilation 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 compilation

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 Hello World classique présente la structure minimale d'un fichier source C++. Les apprenants le compilent et l'exécutent pour confirmer le bon fonctionnement de la chaîne d'outils complète.

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 des besoins de données donnés.

Leçon 3 • Conversions de type et transtypage

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

Leçon 4 • Constantes et littéraux

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

Leçon 1 • Lecture de lignes de texte entières

std::getline lit une ligne entière, espaces compris, contrairement à l'opérateur d'extraction. Les apprenants combinent getline avec cin correctement 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é vers le terminal à l'aide de l'opérateur d'insertion. Les apprenants contrôlent l'espacement, les nouvelles lignes 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 de fois connu ; 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 à vrai ou faux. 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 de conditions. Les apprenants structurent clairement la logique multi-branches et évitent les problèmes de else suspendu.

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 les 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 attendues par une fonction ; 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à des simples push et pop. Les apprenants utilisent insert, erase et find pour manipuler précisément le contenu d'un vecteur.

Leçon 4 • Tableaux bruts en C++

Les tableaux bruts stockent des séquences de taille fixe d'un seul type en 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 empêchent 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 des pointeurs

Le dé-référencement d'un pointeur accède à la valeur à son adresse stockée. Les apprenants effectuent de l'arithmétique des 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 références et pointeurs en fonction des besoins de propriété et de la possibilité de nullité.

Leçon 4 • Allocation mémoire dynamique

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

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

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 même 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 données et comportement. Les apprenants utilisent public et private pour imposer l'encapsulation et exposer des interfaces sûres.