Le langage C++
Partie 2 sur 2
4La mémoire : la force et le piège du C++
Le point qui distingue le C++ de beaucoup d’autres langages est la façon dont il traite la mémoire (voir la gestion de la mémoire). Un programme dispose de deux grandes zones. La pile contient les variables locales d’une fonction ; elles disparaissent seules quand la fonction se termine. Le tas contient les objets dont la durée de vie est choisie par le programmeur ; il faut les réserver, puis les rendre.
4.1Les pointeurs et leurs dangers
Un pointeur est une variable qui contient l’adresse d’une zone de mémoire. Il permet des choses très puissantes (construire des listes, partager de gros objets sans les copier), mais le compilateur ne vérifie presque rien. Voici les erreurs classiques, qu’il faut connaître pour les éviter :
- l’oubli de libérer une zone réservée : la mémoire se remplit peu à peu (une fuite) ;
- la double libération : rendre deux fois la même zone corrompt la gestion de la mémoire ;
- l’usage après libération : continuer à lire ou écrire dans une zone déjà rendue ;
- le débordement : écrire au-delà de la fin d’un tableau, dans la mémoire voisine ;
- l’usage d’une variable jamais initialisée : on lit alors ce qui traînait dans la zone.
Aucune de ces erreurs n’arrête forcément le programme au moment où elle se produit. Il peut continuer à tourner, produire un résultat faux, puis planter longtemps après. C’est ce qui les rend si difficiles à trouver, et si intéressantes pour un attaquant (partie 6).
4.2La solution moderne : posséder, et laisser le programme libérer
La technique moderne s’appelle RAII (Resource Acquisition Is Initialization, un nom compliqué pour une idée simple) : un objet qui réserve une ressource la rend automatiquement quand il disparaît. Quand la pile se défait à la fin d’un bloc, les objets qui s’y trouvent sont détruits et libèrent leur contenu. Le programmeur n’écrit plus de libération.
Cela s’applique à toute la bibliothèque standard. Une liste de nombres de taille variable s’écrit std::vector<int> (un tableau qui grandit seul et se libère seul). Un texte s’écrit std::string. Pour un objet qu’on doit absolument placer sur le tas, on utilise un pointeur intelligent comme std::unique_ptr, qui possède l’objet seul et le détruit à sa sortie, ou std::shared_ptr quand plusieurs parties du programme le partagent. Les mots new et delete (réserver puis libérer) deviennent rares dans le code moderne.
La figure 2 place le C++ moderne entre le C et les langages à ramasse-miettes : on garde la vitesse, mais on laisse des objets s’occuper de la libération. Un langage plus récent comme Rust (voir le langage Rust) va plus loin, en faisant vérifier par le compilateur qui possède chaque objet ; c’est pourquoi il est souvent présenté comme un successeur possible du C++ pour les logiciels critiques.
Pour s’exercer
Exercice 4 : trouver le danger
Une fonction réserve un tableau de dix entiers sur le tas, y écrit onze valeurs avec une boucle, puis oublie de le libérer. Nommez les deux erreurs et proposez une écriture moderne qui les évite.
Voir la réponse
Un débordement (écriture à l’indice 10, hors du tableau) et une fuite (oubli de libération). Avec un std::vector<int> et sa méthode at() qui vérifie les limites, le tableau se libère seul et un accès hors limites déclenche une erreur claire au lieu de corrompre la mémoire.
Exercice 5 : choisir qui libère
Dans un jeu, un objet « Niveau » possède des « Ennemis » ; un seul propriétaire existe pour chaque ennemi. Quel type de pointeur intelligent choisir ? Et si deux modules partagent le même objet de configuration ?
Voir la réponse
Pour un propriétaire unique, std::unique_ptr : il détruit l’ennemi quand le niveau disparaît, sans coût caché. Pour une configuration partagée par plusieurs modules sans propriétaire évident, std::shared_ptr, qui compte les utilisateurs et libère quand le dernier part. On préfère le premier chaque fois que c’est possible, car le second coûte un peu plus et rend la durée de vie moins claire.
Exercice 6 : lire des avertissements
Pourquoi compile-t-on avec -Wall -Wextra même quand le programme « marche » ?
Voir la réponse
Parce que beaucoup d’erreurs que le C++ autorise passent sans bruit : variable non initialisée, comparaison entre un nombre signé et un nombre non signé, valeur de retour oubliée. Un programme qui paraît marcher peut en réalité dépendre d’un comportement imprévisible. Les avertissements les signalent à la compilation, avant qu’elles ne coûtent cher.
5Le C++ moderne
Le C++ n’a d’abord connu qu’une seule norme, celle de 1998 (légèrement corrigée en 2003). Depuis 2011, le comité de normalisation publie une nouvelle version tous les trois ans (figure 3). La version de 2011, appelée C++11, est un tournant : on parle depuis de « C++ moderne ».
5.1Ce qu’ont apporté les versions successives
- C++11 : le mot-clé
auto(le compilateur devine le type d’une variable), les lambdas (petites fonctions écrites sur place), les pointeurs intelligents, la boucle « pour chaque élément », la prise en charge officielle des fils d’exécution (threads, plusieurs tâches en parallèle), et le motnullptrpour un pointeur vide. - C++14 et C++17 : des simplifications et des ajouts de bibliothèque, dont un moyen d’écrire des fonctions qui renvoient « une valeur ou rien » (
std::optional) et de manipuler des fichiers et des dossiers (std::filesystem). - C++20 : les concepts (des contraintes lisibles sur les types qu’un modèle accepte, avec des messages d’erreur plus clairs), les modules (une alternative aux fichiers d’en-tête, plus rapide à compiler), les coroutines (fonctions qui peuvent s’arrêter et reprendre) et les « ranges », une façon de chaîner des traitements sur des suites de valeurs.
- C++23 : des compléments, dont l’affichage simplifié
std::println. - C++26 : terminé techniquement à Londres en mars 2026. Les nouveautés les plus discutées sont la réflexion à la compilation (un programme peut inspecter sa propre structure pour générer du code), les contrats (déclarer des conditions qu’une fonction attend et garantit), des garanties de sécurité renforcées sur les variables non initialisées et sur les accès hors limites dans la bibliothèque standard, et un cadre unifié pour le parallélisme (
std::execution). Cette version doit encore passer les dernières étapes de publication officielle de l’ISO, et les compilateurs en implémentent progressivement des morceaux.
Les modèles (templates) sont la grande idée du C++ moderne : on écrit une fonction ou une classe une fois, avec un « type à définir », et le compilateur en génère une version pour chaque type utilisé. La bibliothèque standard (STL, Standard Template Library) est bâtie ainsi : conteneurs (vector, map pour des paires clé-valeur, set), algorithmes (tri, recherche) et textes sont écrits une seule fois pour tout type.
5.2Un même exemple, deux époques
Pour mesurer l’écart, imaginez un programme qui range des noms dans une liste. En style ancien : on réservait un tableau avec new, on gérait sa taille à la main, on copiait quand il devenait trop petit, et on le libérait avec delete[], en espérant ne rien oublier dans tous les chemins du programme, y compris quand une erreur survient. En style moderne : on déclare un std::vector<std::string>, on ajoute avec push_back, on parcourt avec une boucle simple, et il n’y a plus rien à libérer. Le programme est plus court et plus sûr, avec la même vitesse. Beaucoup de logiciels en C++ qui ont dix ou vingt ans mélangent encore les deux styles, ce qui explique en partie leurs failles.
5.3Une classe pas à pas
Pour voir l’encapsulation en action, voici une petite classe de compte bancaire, écrite en C++ moderne :
#include <stdexcept>
class Compte {
public:
explicit Compte(double depart) : solde_(depart) {}
void deposer(double somme) {
if (somme <= 0) throw std::invalid_argument("somme invalide");
solde_ += somme;
}
double solde() const { return solde_; }
private:
double solde_;
};
Le mot class définit un nouveau type. La partie private contient la donnée cachée, le solde : l’extérieur ne peut pas l’écrire directement. La partie public contient ce qui est offert : un constructeur (la fonction qui prépare l’objet à sa création, ici en fixant le solde de départ), une action deposer qui refuse les sommes négatives en lançant une exception (voir la gestion des erreurs), et une consultation solde(). Le mot const après les parenthèses promet que cette fonction ne modifie pas l’objet. Il n’y a pas de destructeur à écrire : ce compte ne réserve rien qu’il faille rendre. La règle générale, que l’on appelle parfois « la règle du zéro », est de composer ses classes avec des éléments qui se gèrent eux-mêmes (nombres, std::string, std::vector, pointeurs intelligents), pour n’avoir à écrire ni destructeur ni copie à la main.
5.4La bibliothèque standard au quotidien
Une grande partie du travail courant se fait avec une poignée de types. std::vector est le tableau à taille variable, à utiliser par défaut. std::string est le texte. std::map et std::unordered_map associent une clé à une valeur ; la seconde est plus rapide en moyenne, la première garde les clés triées. std::array est un tableau de taille fixe. std::optional exprime « une valeur ou rien ». Côté actions, la bibliothèque propose des algorithmes prêts à l’emploi : std::sort pour trier, std::find pour chercher, std::count_if pour compter selon une condition. Leur avantage est double : ils sont testés par des milliers de projets, et leur nom dit ce qu’ils font, ce qui rend le programme plus lisible qu’une boucle écrite à la main. En lisant du code C++ récent, on cherche donc d’abord le nom de l’algorithme.
6Forces, limites et alternatives
6.1Pourquoi on l’utilise toujours
Quatre raisons expliquent que le C++ reste en usage. La vitesse : pas de machine virtuelle ni de ramasse-miettes, et le compilateur optimise beaucoup. Le contrôle : on choisit comment les données sont rangées en mémoire, ce qui compte pour les jeux et les calculs. La compatibilité : le C++ peut appeler du C directement, donc réutiliser des décennies de bibliothèques. Et la quantité de code existant : réécrire un navigateur ou un moteur de jeu coûterait des années.
6.2Les limites
Le C++ est un langage difficile : il a gardé les anciennes manières en plus des nouvelles, et il demande de connaître beaucoup de règles. Les temps de compilation sont longs sur les gros projets. Les messages d’erreur sur les modèles ont longtemps été illisibles. Surtout, le langage ne protège pas contre les erreurs de mémoire (partie 4).
6.3Les alternatives
Selon les besoins, d’autres langages peuvent faire l’affaire : Rust offre la vitesse avec des garanties de sûreté vérifiées à la compilation ; Go vise la simplicité pour les serveurs ; Zig se veut un successeur plus simple du C ; Java et C# privilégient la productivité avec un ramasse-miettes. Pour un aperçu plus large, voir le panorama des langages récents. Le C++ ne disparaît pas pour autant : le comité travaille à le rendre plus sûr par défaut, et il est probable qu’il reste longtemps le langage des moteurs et des systèmes.
Pour s’exercer
Exercice 7 : C++ ou autre langage ?
Pour chaque projet, dites si le C++ est un choix naturel, et pourquoi : (a) un moteur de jeu en trois dimensions ; (b) un petit site web de réservation ; (c) le pilote d’un appareil médical ; (d) un script qui renomme des fichiers une fois par mois.
Voir la réponse
(a) Oui : vitesse et contrôle de la mémoire. (b) Non : un langage de site web, avec un ramasse-miettes ou un cadre de développement adapté, sera plus simple et plus sûr. (c) Oui, ou un langage comparable (Rust, Ada) : matériel, exigences de temps réel, mais avec des règles de codage strictes et des vérifications supplémentaires, car une erreur est grave. (d) Non : un langage de script suffit.