Documentation C++
Référence C++ concise et illustrée par des exemples. Lisez le concept, voyez le code, puis pratiquez-le dans un parcours Coddy.
Commencer un parcours guidé en C++Pour commencer
- Qu'est-ce que le C++Ce qu'est réellement le C++, pourquoi il se compile directement en code machine natif et les types de logiciels haute performance que l'on construit avec lui.
- Installer C++Comment installer un compilateur C++ (GCC, Clang ou MSVC), choisir une chaîne d'outils adaptée à votre système d'exploitation et vérifier qu'elle fonctionne depuis la ligne de commande.
- Compiler du C++Comment le C++ transforme un source .cpp en exécutable natif : compilez avec g++ (ou clang++/MSVC), lancez le binaire et lisez les erreurs du compilateur quand ça ne va pas.
- Syntaxe C++Les règles fondamentales de syntaxe d'un programme C++ - instructions et points-virgules, blocs entre accolades, la fonction main et le fonctionnement de la sortie - expliquées à partir d'un premier programme.
- CommentairesComment écrire des commentaires en C++ - notes sur une ligne // et blocs multilignes /* */ - en plus de comment commenter du code, pourquoi les commentaires de bloc ne s'imbriquent pas et ce qui rend un commentaire utile à conserver.
Variables et types
- VariablesComment fonctionnent les variables en C++ : les déclarer avec un type, la différence entre affectation et initialisation, l'initialisation par accolades, les règles de nommage et la portée qui décide où une variable vit et meurt.
- Types de donnéesUn tour pratique des types de données fondamentaux du C++ - entiers, virgule flottante, char et bool - ainsi que les tailles, signed et unsigned, les littéraux et suffixes, le dépassement et comment choisir le bon type.
- Mot-clé autoComment le mot-clé `auto` laisse le compilateur déduire le type d'une variable à votre place : ce qu'il supprime, là où il brille et les pièges qui surprennent les débutants.
- Constantes et constComment déclarer des valeurs en lecture seule en C++ avec const, la différence entre const et constexpr, les pointeurs const par rapport aux pointeurs vers const, et les fonctions membres const.
- OpérateursApprenez les opérateurs C++ - arithmétiques, de comparaison, logiques, d'affectation et bit à bit - ainsi que les pièges liés à la division entière, à la priorité et à l'évaluation court-circuit.
- Conversion de typesComment fonctionne la conversion de types en C++ : conversions implicites, le piège de la division entière et les quatre casts nommés (static_cast, const_cast, reinterpret_cast, dynamic_cast), avec les subtilités qui provoquent une perte de données silencieuse.
Flux de contrôle
- if-elseComment prendre des décisions en C++ avec if, else if et else : conditions, enchaînement des branches, imbrication, l'opérateur ternaire, le if avec initialiseur et les pièges qui font trébucher.
- switchL'instruction switch de C++ expliquée : étiquettes case, break et fall-through, la branche default, regrouper les cas, faire un switch sur des enums et les pièges des déclarations à l'intérieur des cas.
- boucle forComment répéter du code avec la boucle for de C++ : l'en-tête en trois parties, compter vers le haut et vers le bas, parcourir des tableaux, imbriquer, break et continue, ainsi que les bugs de décalage d'un et de types non signés qui piègent tout le monde.
- Boucles whileLa boucle while de C++ expliquée : le while qui teste d'abord la condition, le do-while qui s'exécute au moins une fois, boucler jusqu'à une valeur sentinelle, break et continue, et comment éviter les boucles infinies.
- for basée sur un intervalleLa boucle for basée sur un intervalle en C++ expliquée : itération propre sur les tableaux, vectors, strings et maps, pourquoi utiliser auto& et const auto&, et les pièges de copie et d'invalidation d'itérateurs à éviter.
Fonctions
- FonctionsComment écrire des fonctions en C++ : l'anatomie type de retour/nom/paramètres, déclarations contre définitions, renvoyer des valeurs, fonctions void et les pièges comme l'oubli du return ou du prototype.
- Paramètres de fonctionComment les arguments entrent dans les fonctions C++ - passage par valeur ou par référence, références const pour un accès en lecture seule peu coûteux, arguments par défaut, pointeurs, et les pièges du coût de copie qui ralentissent les programmes en silence.
- RéférencesLes références C++ expliquées : comment le & dans un paramètre crée un alias, pourquoi le passage par référence évite les copies et permet à une fonction de modifier les variables de l'appelant, et quand recourir à const& et aux références plutôt qu'au retour par valeur.
- Surcharge de fonctionsLa surcharge de fonctions en C++ permet à plusieurs fonctions de partager un même nom tant que leurs listes de paramètres diffèrent. Apprenez comment la résolution de surcharge choisit la bonne version, pourquoi le type de retour seul ne compte pas, et les pièges d'ambiguïté et d'arguments par défaut à éviter.
- LambdasÉcrivez de petites fonctions en ligne à la volée avec les lambdas du C++ : la syntaxe, le fonctionnement des captures, quand utiliser `mutable` et le piège de la capture pendante qui piège tout le monde.
Pointeurs et mémoire
- PointeursLes pointeurs en C++ expliqués depuis zéro : déclarer un pointeur, les opérateurs & (adresse de) et * (déréférencement), nullptr, les pointeurs vers des tableaux et les pièges des pointeurs pendants et non initialisés qui provoquent des plantages.
- Références vs pointeursUne comparaison pratique entre références et pointeurs en C++ : ce qu'ils ont en commun, là où ils diffèrent (réassociation, nullité, arithmétique) et une règle claire pour choisir lequel utiliser au quotidien.
- Mémoire dynamiqueComment allouer de la mémoire à l'exécution avec `new`, la libérer avec `delete`, et éviter les fuites, les pointeurs ballants et les doubles libérations qui accompagnent la gestion manuelle du tas.
- Pointeurs intelligentsLes pointeurs intelligents possèdent la mémoire du tas et la libèrent automatiquement. Apprends `unique_ptr`, `shared_ptr`, `make_unique` et `make_shared`, et pourquoi tu ne devrais presque plus jamais écrire `new`/`delete`.
Chaînes et E/S
- ChaînesComment utiliser `std::string` en C++ - construire, joindre, rechercher et découper du texte en toute sécurité, et pourquoi on ne veut presque jamais un `char*` brut pour du vrai travail.
- Entrée et sortieComment fonctionnent les E/S console en C++ : afficher avec cout, lire avec cin, le classique bug du saut de ligne avec getline après cin, et comment s'en sortir quand la saisie échoue.
- Flux de chaînesComment utiliser std::stringstream, istringstream et ostringstream pour analyser du texte, découper des chaînes selon les espaces, convertir entre chaînes et nombres, et construire des chaînes formatées en mémoire.
Conteneurs STL
- TableauxLes tableaux natifs de C++ expliqués : comment les déclarer et les initialiser, indexer sans risque, les parcourir avec leur taille, le piège de la conversion tableau-vers-pointeur, et pourquoi std::array et vector sont généralement préférables.
- vectorstd::vector est le tableau redimensionnable du C++ - le conteneur vers lequel se tourner par défaut. Apprends à créer, accéder, agrandir et parcourir un vector, ainsi que les pièges de l'invalidation des itérateurs et de l'accès hors limites.
- mapLe std::map de C++ expliqué : un conteneur clé-valeur trié avec recherche logarithmique. Insérez, recherchez, parcourez et évitez le classique piège d'operator[] qui insère des clés en silence.
- unordered_mapApprends std::unordered_map en C++ - le cousin de map basé sur une table de hachage qui offre une insertion et une recherche en O(1) en moyenne. Couvre les opérations de base, le piège de l'insertion automatique de [], count contre find, et quand le préférer à un map ordonné.
- setComment std::set stocke des valeurs uniques et automatiquement triées en C++ : insérer, vérifier l'appartenance avec count et find, itérer dans l'ordre, et les différences entre set, multiset et unordered_set.
- pair et tupleComment `std::pair` et `std::tuple` regroupent deux valeurs ou plus dans un seul objet : comment les créer, accéder aux champs, les structured bindings et la place de chacun.
- ItérateursComment les itérateurs C++ fonctionnent comme des pointeurs généralisés vers les conteneurs : begin() et end(), le déréférencement, l'avancement, les variantes const/reverse et les pièges d'invalidation et de déréférencement de end() qui provoquent un comportement indéfini.
Algorithmes STL et templates
- AlgorithmesUtilisez les algorithmes standard du C++ - `find`, `count_if`, `transform`, `accumulate`, `remove` - pour traiter réellement des plages sans écrire de boucles à la main, ainsi que les pièges de la paire d'itérateurs et de l'idiome erase-remove.
- TriTriez des vecteurs et des tableaux en C++ avec `std::sort` : ordre par défaut, comparateurs personnalisés, tri de structs par un champ et le piège de l'ordre faible strict qui provoque des plantages.
- TemplatesÉcrivez le code une seule fois et faites-le fonctionner pour tous les types grâce aux templates C++ : templates de fonction, templates de classe, déduction de type et les déroutantes erreurs de compilation qu'ils provoquent.
Classes et objets
- ClassesDécouvrez comment les classes C++ regroupent données et comportement dans des types réutilisables : déclarer des variables membres et des méthodes, créer des objets, la séparation public/private et les pièges comme les membres non initialisés et le pointeur this.
- ConstructeursUn constructeur est la fonction membre spéciale qui s'exécute lorsqu'un objet est créé. Découvrez les constructeurs par défaut, paramétrés et de copie, les listes d'initialisation de membres, et comment éviter de laisser des objets à moitié initialisés.
- DestructeursUn destructeur s'exécute automatiquement quand un objet est détruit. Découvrez la syntaxe `~NomClasse()`, quand il se déclenche, pourquoi il libère les ressources et la Règle de Trois/Cinq.
- HéritageDécouvrez comment l'héritage en C++ permet à une classe dérivée de réutiliser et d'étendre une classe de base : la syntaxe, l'héritage public et privé, l'ordre des constructeurs et destructeurs, et les pièges comme le slicing d'objets.
- Fonctions virtuellesLes fonctions virtuelles permettent à un pointeur de classe de base d'appeler à l'exécution la version de la méthode de la classe dérivée. Découvrez `virtual`, `override`, les classes abstraites et pourquoi le destructeur de la base doit être virtuel.
- Surcharge d'opérateursLa surcharge d'opérateurs en C++ permet à vos propres types de fonctionner avec les opérateurs intégrés comme +, == et <<. Découvrez les règles fonction membre vs non membre, comment surcharger les opérateurs de comparaison et de flux, et les pièges autour des types de retour et de l'opérateur d'affectation.
- Spécificateurs d'accèsComment public, private et protected contrôlent qui peut toucher aux membres d'une classe en C++ - le fondement de l'encapsulation, avec les getters, les setters et l'échappatoire friend.
- StructsLes structs en C++ expliqués : comment regrouper des variables liées dans un seul type, déclarer et initialiser des objets struct, doter un struct de fonctions membres et de constructeurs, et en quoi struct diffère vraiment de class.
- enumsApprenez les enums en C++ : comment les déclarer, pourquoi l'enum class à portée est plus sûr que l'enum simple, les valeurs sous-jacentes personnalisées, le switch sur les énumérateurs et la conversion vers et depuis les entiers.
Erreurs et débogage
- ExceptionsLes exceptions signalent des erreurs qu'une fonction ne peut pas traiter localement. Apprenez à utiliser `throw`, quels sont les types d'exception standard, le message de `what()` et pourquoi les exceptions valent mieux que les codes de retour pour les échecs qui comptent vraiment.
- try-catchEntourez le code risqué d'un `try`, réagissez dans un `catch`. Apprenez à intercepter les exceptions par référence constante, à ordonner plusieurs gestionnaires, à utiliser `catch (...)` et à relancer, sans fuite de ressources.
- Comportement indéfiniLe comportement indéfini (UB) désigne du code sur lequel la norme C++ n'impose aucune règle : il peut planter, corrompre des données ou sembler fonctionner. Découvrez les causes courantes, pourquoi « ça a marché » ne prouve rien et les outils qui détectent l'UB.
