Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Le Langage C++, 3è édition

Le Langage C++, 3è édition

Titre original: The C++ Programming Language
Concevez des programmes C++ qui restent efficaces en grandissant, en explicitant la propriété des ressources et les interfaces.
par Bjarne Stroustrup 1986 1030 pages
4.10
4 000+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérez le C++ comme un langage permettant de construire des abstractions efficaces, et non d’accumuler des fonctionnalités

L’idée centrale de la conception. Le C++ vise à associer un accès direct au matériel à des abstractions sûres, expressives et efficaces. Idéalement, une fonctionnalité ne devrait entraîner aucun coût lorsqu’elle n’est pas utilisée, tandis que les types définis par l’utilisateur devraient pouvoir s’utiliser presque aussi naturellement que les types intégrés. Cet équilibre est né de la combinaison des atouts du C pour la programmation système et des outils de Simula permettant d’organiser les programmes autour de concepts.

Apprendre par composition. Le livre présente le langage à l’aide d’une petite calculatrice, puis montre comment son analyseur lexical, son analyseur syntaxique, sa table des symboles et son programme pilote s’articulent. Il ne s’agit pas d’apprendre par cœur chaque fonctionnalité, mais de comprendre comment les classes, les modèles et les bibliothèques se combinent pour exprimer une conception. Le C++ est présenté comme un outil pour des logiciels sérieux et pérennes, et non comme un paradigme à usage unique.

Analyse

Ce qui frappe, c’est que le livre traite les performances et l’abstraction comme des contraintes de conception conjointes, plutôt que comme les deux camps d’un débat. Cette approche aide à comprendre pourquoi un vector ou une string peut être à la fois un concept pratique et une structure efficace de bas niveau. La tension reste réelle : le principe de surcoût nul est un objectif, pas un résultat automatique, et des modèles complexes ou une gestion imprudente de la propriété peuvent entraîner des coûts de compilation, de mémoire ou de maintenance. Le critère pratique consiste à se demander si une abstraction clarifie le programme sans masquer les coûts importants.

Définissez un invariant clair pour chaque classe, puis faites en sorte que son interface le protège

Définissez ce qui doit toujours être vrai. Un invariant de classe est une condition qui doit être satisfaite chaque fois qu’un objet est utilisé. Dans l’exemple Vector du livre, le pointeur vers les éléments doit désigner un tableau dont la longueur correspond à la taille enregistrée. Le fait de garder cette représentation privée empêche les appelants de rompre discrètement cette relation. Les opérations publiques constituent la voie contrôlée d’accès aux données de l’objet.

Établissez l’invariant dès le départ. Un constructeur doit créer un objet valide ou signaler un échec, et non laisser un objet à moitié utilisable. L’exemple Date vérifie que le jour, le mois et l’année sont cohérents; l’exemple Vector rejette une taille invalide. Les fonctions membres peuvent alors s’appuyer sur l’invariant sans devoir se prémunir sans cesse contre tous les états mal formés possibles.

Analyse

Un invariant de classe est un contrat concis entre le constructeur, les méthodes et toutes les personnes qui utilisent l’objet. Son intérêt ne se limite pas à réduire le nombre de bogues : il diminue le nombre d’états qu’un programmeur doit prendre en compte pour raisonner sur un système. Cela ressemble à une frontière dans la conception des systèmes, où la complexité est contenue derrière une interface étroite. Il importe aussi d’en reconnaître la limite : l’encapsulation protège contre les mauvais usages involontaires, pas contre les contournements délibérés, et un invariant n’est utile que si sa définition est précise et son respect assuré.

Acquérez les ressources dans les constructeurs et libérez-les automatiquement dans les destructeurs

Rendez la propriété explicite. L’acquisition de ressources lors de l’initialisation (RAII) lie la durée de vie d’une ressource à celle d’un objet. Un constructeur de Vector acquiert de la mémoire, et son destructeur la libère. Le même principe s’applique aux fichiers et aux verrous. Lorsqu’un objet local sort de portée, son destructeur est exécuté, y compris lors de la gestion d’une exception: le nettoyage ne dépend donc pas de l’exécution d’une ligne de code précise.

Distinguez l’échec du nettoyage. Si un constructeur ne peut pas établir son invariant, il lance une exception. Pendant le dépilage de la pile, les objets déjà construits libèrent leurs ressources. Cela permet d’offrir des garanties en cas d’exception: au minimum, les opérations doivent éviter les fuites et laisser les objets dans un état valide; les opérations importantes peuvent fournir la garantie plus forte selon laquelle elles réussissent ou n’ont aucun effet. Évitez les `new` et `delete` nus dans le code d’application ordinaire.

Analyse

RAII transforme le nettoyage, qui dépendrait autrement de la mémoire du programmeur, en une propriété de la portée et de la conception des objets. C’est particulièrement puissant, car les échecs surviennent souvent loin du code qui a acquis une ressource. Le principe s’étend aussi au-delà de la mémoire : un garde de verrou peut libérer un mutex, et un descripteur de fichier peut fermer un fichier. Cette discipline exige toutefois que les ressources soient systématiquement encapsulées. Un seul pointeur non géré ou un destructeur qui lance une exception peut compromettre la sûreté de la conception environnante.

Choisissez les sémantiques de copie, de déplacement et de propriété avant qu’elles ne s’imposent à vous

La copie doit avoir un sens. La copie par défaut du compilateur copie les membres un à un. Pour un Vector qui contient un pointeur vers des éléments alloués, cela ferait partager la même allocation à deux objets, entraînant des modifications accidentelles et une double libération. Un constructeur de copie correct alloue ses propres éléments et en copie les valeurs. Les classes qui possèdent des ressources doivent déterminer si la copie a un sens et, le cas échéant, comment elle fonctionne.

Déplacez lorsque la source peut être vidée. Une opération de déplacement transfère une ressource au lieu de la dupliquer. Déplacer une grande Matrix peut consister à transférer son pointeur de stockage et à laisser la source dans un état valide pour sa destruction ou sa réaffectation. Utilisez `unique ptr` pour une propriété exclusive et `shared ptr` uniquement lorsque la propriété est réellement partagée. Un pointeur partagé évite certaines fuites, mais ne résout ni les courses de données ni le manque de clarté des droits d’accès.

Analyse

La distinction entre copie et déplacement concerne en réalité la propriété, et pas seulement la vitesse. Dès qu’un type représente un fichier, un tampon ou une allocation sur le tas, ses opérations définissent qui est responsable de sa durée de vie. Des choix explicites rendent ces responsabilités lisibles. La propriété partagée est utile, mais elle rend aussi le moment de la destruction plus difficile à prévoir et peut créer des cycles. La conception la plus solide ne repose souvent pas sur une politique de pointeurs ingénieuse, mais sur un type dont l’utilisation ordinaire rend la propriété et le nettoyage prévisibles.

Utilisez les conteneurs et algorithmes standard avant d’écrire des boucles de bas niveau

Laissez les conteneurs gérer le stockage. La bibliothèque standard fournit des vecteurs, des listes, des tables associatives et des conteneurs à hachage. Le livre recommande par défaut Vector pour les séquences: ses éléments sont contigus, leur parcours est efficace et le conteneur s’agrandit au moyen d’opérations comme `push back()`. Les listes permettent des insertions sans déplacer les autres éléments, tandis que les tables associatives ordonnées et non ordonnées permettent des recherches par clé.

Distinguez le stockage des opérations. Des algorithmes comme `find()`, `sort()` et `accumulate()` travaillent au moyen d’itérateurs; un même algorithme peut donc s’appliquer à différents conteneurs. Une paire d’itérateurs décrit une séquence semi-ouverte, qui va du premier élément jusqu’à la fin, sans inclure celle-ci. Cette séparation favorise la réutilisation. Elle a aussi une limite: une paire d’itérateurs ne garantit pas à elle seule que la plage de sortie est suffisamment grande.

Analyse

La contribution la plus profonde de la STL est d’ordre organisationnel : les conteneurs possèdent les données, les itérateurs exposent les séquences et les algorithmes travaillent sur ces séquences sans avoir à connaître la conception du stockage. Cette séparation constitue une forme forte de modularité. Elle implique aussi que le programmeur doit comprendre les catégories d’itérateurs et les règles d’invalidation ; une notation générique ne rend pas toutes les opérations aussi peu coûteuses ni aussi sûres. Choisir Vector par défaut est un point de départ pratique, et non l’affirmation qu’un seul conteneur convient à toutes les charges de travail.

Utilisez l’héritage pour une véritable substituabilité, et non comme réflexe d’organisation par défaut

Modélisez une véritable hiérarchie. Un Circle peut être traité comme un Shape, car ils partagent une interface qui a un sens. Une classe abstraite comme Shape définit des opérations telles que `draw()` sans imposer de représentation. Les classes dérivées fournissent leurs propres implémentations, et la répartition dynamique des appels choisit la bonne lorsqu’un code utilise un pointeur ou une référence vers la classe de base.

Distinguez les interfaces de la réutilisation de l’implémentation. Une classe de base peut fournir une implémentation commune ou servir uniquement d’interface; confondre ces rôles fragilise les hiérarchies. Évitez les étiquettes de type et les conversions descendantes manuelles lorsqu’une fonction virtuelle exprime directement l’opération. Utilisez `dynamic cast` lorsque la navigation dans la hiérarchie est réellement nécessaire, et non pour remplacer une interface claire.

Analyse

L’héritage est le plus convaincant lorsqu’il exprime une relation sur laquelle les appelants peuvent compter : un objet dérivé peut se substituer à sa classe de base sans comportement surprenant. Il l’est moins lorsqu’il sert de raccourci pour emprunter du code, car un état partagé et des hypothèses cachées rendent les modifications ultérieures risquées. Les interfaces abstraites aident à distinguer ces deux usages. La mise en garde du livre contre les étiquettes de type est tout aussi importante : si une hiérarchie demande constamment de quel type est un objet, c’est peut-être que les opérations devraient être exprimées par des fonctions virtuelles.

Laissez les modèles généraliser les algorithmes tout en explicitant les exigences liées aux types

Généralisez à partir d’exemples concrets qui fonctionnent. La programmation générique commence par la recherche des caractéristiques communes à plusieurs implémentations concrètes. L’exemple `sum()` du livre généralise le calcul de la somme d’un vector d’entiers, d’une liste de nombres à virgule flottante ou d’un vector de nombres complexes. Les modèles permettent au compilateur de générer du code pour chaque type sans l’indirection à l’exécution qu’exige la répartition dynamique des appels virtuels.

Nommez les exigences. Un concept est un ensemble de conditions syntaxiques et sémantiques auxquelles les arguments d’un modèle doivent satisfaire. Par exemple, un algorithme de tri nécessite une opération d’ordre, tandis qu’un algorithme de conteneur requiert des itérateurs adaptés. C++11 ne vérifie pas directement les concepts à l’interface du modèle; les erreurs peuvent donc n’apparaître qu’à l’instanciation d’une spécialisation. La vérification de contraintes peut améliorer les diagnostics, mais elle ne remplace pas une conception précise.

Analyse

Les modèles déplacent la flexibilité au moment de la compilation : un même algorithme peut servir à des types sans lien entre eux dès lors qu’ils satisfont aux mêmes exigences, sans les forcer à entrer dans une hiérarchie de classes. C’est une solution de rechange puissante au polymorphisme à l’exécution. Son point faible tient au moment où les erreurs sont détectées. Comme le compilateur ne découvre souvent une incompatibilité qu’à l’instanciation, un modèle peut être plus difficile à utiliser que ne le laisse croire la concision de son interface. Documenter explicitement les concepts et effectuer des tests avec des types d’arguments volontairement minimaux aide à mettre en évidence les dépendances accidentelles.

Structurez les programmes autour d’interfaces stables, et non en empilant arbitrairement des fichiers source

Séparez l’interface de l’implémentation. Une déclaration indique aux utilisateurs ce qu’un module fournit; une définition explique son fonctionnement. Les espaces de noms regroupent les déclarations apparentées et limitent les collisions, tandis que les en-têtes exposent les interfaces entre unités de traduction. L’exemple de la calculatrice répartit le travail entre un analyseur syntaxique, un analyseur lexical, une table des symboles, un programme pilote et un gestionnaire d’erreurs; les dépendances deviennent ainsi visibles au lieu de laisser tous les noms dans un seul espace de noms global.

Veillez à la cohérence des déclarations. La règle de définition unique exige une définition unique et cohérente de chaque entité dans l’ensemble du programme. Les gardes d’inclusion empêchent les inclusions répétées, et les en-têtes autonomes aident à repérer les incohérences. Un module peut avoir une petite interface destinée aux utilisateurs et une interface d’implémentation plus étendue. Cette structure supplémentaire devient précieuse lorsque le programme prend de l’ampleur ou que plusieurs personnes en assurent la maintenance.

Analyse

L’organisation physique des fichiers n’est utile que si elle reflète les frontières logiques. Un en-tête qui expose des détails d’implémentation crée des dépendances qui rendent les modifications coûteuses ; un en-tête unique et surdimensionné peut imposer une recompilation généralisée. Les espaces de noms facilitent la gestion des noms, mais ne créent pas à eux seuls de modularité. Le travail de conception essentiel consiste à déterminer ce que les utilisateurs doivent savoir et ce qui peut rester privé. Ce choix influe sur la compréhension, le temps de compilation et le coût des modifications futures.

Concevez le travail concurrent sous forme de tâches et réduisez au minimum les données modifiables partagées

Commencez par les tâches. Une tâche est un travail susceptible de s’exécuter concurremment; un thread est le mécanisme au niveau du système qui l’exécute. La bibliothèque standard peut lancer une fonction ou un objet fonction dans un thread, et `future`, `promise`, les tâches empaquetées et `async()` permettent aux tâches d’échanger des résultats sans devoir expliciter chaque verrou.

Partagez avec prudence. Les threads partagent un espace d’adressage; un accès simultané et non synchronisé au même emplacement mémoire peut donc provoquer une course de données et un comportement indéfini. Un mutex peut protéger l’état partagé, et un garde de verrou le libère automatiquement. Privilégiez les échanges orientés tâches et mesurez les performances avant de supposer que la mémoire partagée est plus rapide. Avec `async()`, le système choisit le nombre de threads à utiliser; les tâches qui lui sont confiées ne doivent donc pas dépendre de ressources partagées nécessitant un verrouillage explicite.

Analyse

L’approche qui privilégie les tâches concentre l’attention sur le travail et les résultats, au lieu de laisser les mécanismes des threads dominer la conception. Les futures offrent une frontière particulièrement claire : une tâche produit une valeur, une autre l’attend. Les données modifiables partagées restent une source de coûts de coordination, même lorsque les verrous empêchent la corruption. Les abstractions n’éliminent toutefois ni les choix d’ordonnancement, ni l’annulation, ni les compromis de performance. Une version parallèle n’est justifiée que si les mesures montrent que le gain compense la coordination supplémentaire.

Analyse

L’idée directrice la plus forte du livre est que le C++ ne se comprend pas au mieux comme une liste de fonctionnalités syntaxiques. C’est un système permettant d’exprimer en code des types, la propriété, des interfaces et des algorithmes, tout en conservant la possibilité de travailler au plus près du matériel. Ce principe relie des chapitres qui pourraient autrement sembler sans rapport: un constructeur établit un invariant de classe; un destructeur libère les ressources nécessaires à son maintien; les modèles généralisent les opérations à différents types; les itérateurs dissocient les algorithmes des conteneurs; et les classes abstraites permettent la substitution à l’exécution. Chaque mécanisme est le plus efficace lorsqu’il rend une relation explicite plutôt que de s’en remettre aux commentaires ou aux conventions.

La tension centrale oppose flexibilité et intelligibilité. Les modèles permettent une réutilisation efficace sans hiérarchie d’héritage commune, mais leurs exigences ne sont pas directement exprimées en C++11; les erreurs peuvent donc surgir tardivement et dans des contextes peu familiers. L’héritage offre de la flexibilité à l’exécution, mais des classes de base trop générales peuvent exposer des détails d’implémentation ou transformer la réutilisation du code en couplage fragile. Les pointeurs partagés simplifient la gestion de la durée de vie, tout en rendant moins prévisibles la propriété et le moment de la destruction. La concurrence accroît les enjeux: la sûreté des types et RAII réduisent certains risques, mais les états modifiables partagés exigent toujours une coordination attentive.

Le livre propose donc une hiérarchie pratique de choix. Préférez un type concret lorsque son comportement et sa représentation sont stables. Utilisez des modèles lorsqu’un algorithme doit fonctionner avec plusieurs types répondant à des exigences communes. Recourez aux interfaces virtuelles lorsque le type réel doit être choisi à l’exécution. Encapsulez les ressources pour que leur nettoyage suive la durée de vie des objets, et gardez les interfaces plus étroites que les implémentations. Cela ne garantit pas que le C++ fera disparaître la complexité. Sa valeur distinctive tient aux mécanismes qu’il offre pour placer cette complexité à des frontières identifiables, où les programmeurs peuvent la comprendre, la tester et la remplacer sans réécrire tout le système. L’ampleur de l’ouvrage de référence reflète le prix de cette flexibilité: bien programmer en C++ dépend moins de la connaissance de chaque fonctionnalité que du choix du bon niveau d’abstraction pour chaque problème.

Résumé en 30 secondes
C++ associe le contrôle de bas niveau à des abstractions capables de rester efficaces. Protégez l’état valide de chaque type derrière son interface et liez le nettoyage des ressources à la durée de vie des objets afin que les défaillances ne provoquent pas de fuites. Décidez comment les ressources possédées sont copiées, transférées ou partagées. Privilégiez les conteneurs standard et les algorithmes réutilisables ; utilisez les modèles pour la généralité à la compilation et les interfaces virtuelles pour la substitution à l’exécution. Dans les programmes concurrents, limitez les données mutables partagées afin de réduire les courses de données.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.10 sur 5
Moyenne de 4 000+ évaluations de Goodreads et Amazon.

Le Langage C++, 3è édition est largement considéré comme l’ouvrage de référence incontournable sur C++, écrit par le créateur du langage. Si l’étendue de son contenu et la richesse de ses analyses sont saluées, de nombreux lecteurs estiment qu’il ne convient pas aux débutants. Le livre est décrit comme dense, parfois prolixe, et plus utile comme ouvrage de référence que comme outil d’apprentissage. Les programmeurs expérimentés apprécient sa profondeur et ses détails techniques. Certains critiquent le style et l’organisation, tandis que d’autres le jugent essentiel pour maîtriser C++. Dans l’ensemble, il est considéré comme une ressource précieuse pour les professionnels, mais difficile d’accès aux novices.

Votre note :
4.49
197 évaluations
Envie de lire le livre complet ?

Glossaire

acquisition de ressources lors de l’initialisation

Lier la durée de vie des ressources à celle des objets

Technique de gestion des ressources qui consiste pour un objet à acquérir une ressource lors de sa construction et à la libérer lors de sa destruction. Comme les destructeurs sont exécutés lorsque les objets sortent de portée, le nettoyage a lieu lors des retours ordinaires comme pendant le déroulement de la pile après une exception. Cette technique s’applique à la mémoire, aux fichiers, aux verrous et à d’autres ressources ; c’est la méthode centrale du livre pour éviter les fuites.

invariant de classe

Condition préservée par tout objet valide

Énoncé de ce qui doit être vrai pour chaque objet utilisable d’une classe. Le constructeur établit l’invariant et les fonctions membres le préservent. Par exemple, un Vector peut exiger que son pointeur vers les éléments désigne un espace de stockage contenant exactement le nombre d’éléments enregistré. Les invariants clarifient la conception et simplifient le raisonnement sur les erreurs.

principe de surcoût nul

Les fonctionnalités inutilisées n’imposent aucun coût

Objectif de conception de C++ selon lequel une fonctionnalité du langage ou une abstraction ne devrait consommer ni temps d’exécution ni mémoire lorsqu’elle n’est pas utilisée. Lorsqu’elle l’est, elle ne devrait pas être moins efficace qu’une solution raisonnable écrite à la main. Ce principe motive les classes légères, les modèles et les composants efficaces de la bibliothèque standard, mais reste un objectif de conception plutôt qu’une garantie pour chaque programme.

STL

Conteneurs, itérateurs et algorithmes

Partie de la bibliothèque standard C++ fondée sur les conteneurs séquentiels et associatifs, les itérateurs et les algorithmes. Les conteneurs gèrent des collections d’éléments ; les itérateurs décrivent des séquences ; les algorithmes opèrent au moyen d’itérateurs plutôt que de dépendre d’une structure de stockage particulière. Cette conception favorise la réutilisation entre conteneurs tout en conservant la vérification des types à la compilation.

fonction virtuelle

Sélectionner une redéfinition à l’exécution

Fonction membre d’une classe qui peut être redéfinie dans les classes dérivées. Lorsqu’elle est appelée au moyen d’un pointeur ou d’une référence vers la classe de base, l’implémentation associée au type réel de l’objet est sélectionnée à l’exécution. Les fonctions virtuelles prennent en charge le polymorphisme à l’exécution et sont essentielles aux interfaces destinées à représenter plusieurs implémentations dérivées.

référence rvalue

Référence utilisée pour déplacer des valeurs

Type de référence, noté &&, qui peut se lier à une rvalue plutôt qu’à une lvalue. Il permet aux constructeurs et opérateurs d’affectation par déplacement de transférer des ressources depuis des objets qui n’ont pas besoin de conserver leurs valeurs précédentes. Après un déplacement, l’objet source doit rester valide pour être détruit ou réaffecté, même si sa valeur peut être indéterminée.

concept

Exigences imposées aux arguments d’un modèle

Ensemble d’exigences syntaxiques et sémantiques qu’un modèle attend des types de ses arguments. Par exemple, un algorithme de tri a besoin d’une opération de comparaison, tandis qu’un algorithme de conteneur a besoin d’itérateurs adaptés. Le livre présente les concepts comme un outil de conception et de documentation, tout en signalant que C++11 ne permet pas de les vérifier directement aux interfaces des modèles.

recherche dépendante des arguments

Rechercher des fonctions dans les espaces de noms associés aux arguments

Règle de recherche de noms qui examine les espaces de noms associés aux types des arguments d’une fonction lorsqu’elle recherche une fonction correspondante. Elle permet aux opérateurs et aux fonctions de fonctionner naturellement avec des types définis par l’utilisateur, sans qu’il soit nécessaire de qualifier explicitement l’espace de noms à chaque appel. Les modèles trop généraux trouvés de cette manière peuvent entraîner des résolutions de surcharge surprenantes.

modèle mémoire

Règles d’accès à la mémoire partagée

Garanties définies au niveau du langage qui décrivent comment les threads peuvent accéder à la mémoire et observer les opérations les uns des autres. Le modèle définit les conditions dans lesquelles les accès concurrents sont sûrs et la manière dont la synchronisation établit un ordre. Il vise à rendre prévisible le comportement du code ordinaire exempt de courses de données, tout en permettant aux implémentations d’exploiter le matériel moderne.

FAQ

1. De quoi parle « Le Langage C++, 3è édition » de Bjarne Stroustrup ?

  • Référence complète sur C++ : Le livre est un guide approfondi de C++, qui couvre les fonctionnalités du langage et les composants de la bibliothèque standard dont un programmeur professionnel est susceptible d’avoir besoin.
  • Accent sur le C++ moderne : Il met l’accent sur C++11 et les normes ultérieures, et enseigne des techniques fondamentales comme avancées, notamment la programmation orientée objet et la programmation générique.
  • Pratique et théorique : Le livre associe des conseils pratiques de programmation à des explications des concepts sous-jacents et des principes de conception ; il s’adresse ainsi aussi bien aux débutants qu’aux programmeurs avancés.
  • Place importante accordée à la bibliothèque standard : Il présente la bibliothèque standard C++ et encourage son utilisation pour simplifier les tâches de programmation et favoriser un code efficace et facile à maintenir.

2. Pourquoi lire « Le Langage C++, 3è édition » de Bjarne Stroustrup ?

  • Conseils faisant autorité : Écrit par Bjarne Stroustrup, le créateur de C++, le livre offre un éclairage approfondi sur la conception et l’évolution du langage, ainsi que sur les bonnes pratiques.
  • Contenu à jour : Il couvre les fonctionnalités du C++ moderne, notamment C++11 et les versions ultérieures, afin d’aider les lecteurs à suivre l’évolution du langage et les extensions de la bibliothèque standard.
  • Priorité aux logiciels de qualité : Le livre insiste sur la nécessité d’écrire du code correct, facile à maintenir et efficace, et propose des conseils sur la concurrence, la gestion de la mémoire et les abstractions.
  • Une ressource durable : Il sert à la fois de tutoriel et d’ouvrage de référence, ce qui en fait un outil précieux pour continuer à apprendre et résoudre des problèmes.

3. Quels sont les principaux enseignements de « Le Langage C++, 3è édition » de Bjarne Stroustrup ?

  • Maîtriser les mécanismes d’abstraction : Le livre enseigne à utiliser les classes, les modèles et la bibliothèque standard pour écrire du code expressif, sûr du point de vue des types et efficace.
  • Adopter le C++ moderne : Il encourage l’adoption de fonctionnalités de C++11 telles que la sémantique de déplacement, les lambdas et les pointeurs intelligents, pour obtenir un code plus sûr et plus clair.
  • Gestion des ressources et RAII : Stroustrup insiste sur l’acquisition de ressources lors de l’initialisation (RAII) et sur les pointeurs intelligents pour gérer les ressources et éviter les fuites.
  • Combiner les styles de programmation : Les lecteurs apprennent à combiner efficacement programmation procédurale, orientée objet et générique afin de concevoir des logiciels robustes.

4. Quelles sont les meilleures citations de « Le Langage C++, 3è édition » de Bjarne Stroustrup, et que signifient-elles ?

  • « Le but de l’informatique est la compréhension, pas les nombres. » – R. W. Hamming : Cette citation souligne que la programmation doit viser à apporter compréhension et clarté, et pas seulement à traiter des données.
  • « Faites simple : aussi simple que possible, mais pas plus. » – A. Einstein : Stroustrup s’en sert pour souligner l’importance de la simplicité en programmation concurrente et générale, afin d’éviter toute complexité superflue.
  • « Il existe deux sortes de connaissances : nous connaissons nous-mêmes un sujet, ou nous savons où trouver des renseignements à son propos. » – Samuel Johnson : Cette citation rappelle l’intérêt de savoir apprendre et de savoir où chercher des informations, compétence essentielle pour les programmeurs.
  • Des citations comme guides : Ces citations ponctuent le livre et renforcent les philosophies et bonnes pratiques essentielles en programmation.

5. Quels styles de programmation et mécanismes d’abstraction « Le Langage C++, 3è édition » de Bjarne Stroustrup prend-il en charge ?

  • Quatre grands styles : Le livre traite de programmation procédurale, d’abstraction des données, de programmation orientée objet et de programmation générique, et montre comment les combiner efficacement.
  • Classes et hiérarchies : Il explique comment les classes, l’héritage et le polymorphisme permettent l’encapsulation et la réutilisation du code.
  • Modèles et programmation générique : Les modèles permettent d’écrire du code flexible et sûr du point de vue des types, réutilisable avec différents types, et prennent en charge la métaprogrammation ainsi que les calculs à la compilation.
  • Gestion des ressources : RAII et les pointeurs intelligents sont présentés comme des outils essentiels pour gérer les ressources de façon sûre et efficace.

6. Comment Bjarne Stroustrup définit-il la gestion des ressources et RAII, et quels conseils donne-t-il à ce sujet dans « Le Langage C++, 3è édition » ?

  • Principe RAII : L’acquisition de ressources lors de l’initialisation lie la durée de vie des ressources à celle des objets, garantissant leur libération correcte même en présence d’exceptions.
  • Pointeurs intelligents : Le livre présente unique_ptr pour la propriété exclusive, shared_ptr pour la propriété partagée et weak_ptr pour rompre les cycles de références, afin d’automatiser la gestion de la mémoire.
  • Éviter la gestion manuelle : Stroustrup déconseille la gestion manuelle de la mémoire au moyen de pointeurs bruts et recommande plutôt les conteneurs standard et les pointeurs intelligents.
  • Sécurité face aux exceptions : RAII est essentiel pour écrire du code sûr face aux exceptions, éviter les fuites de ressources et simplifier la gestion des erreurs.

7. Quelles sont les principales fonctionnalités et recommandations concernant la concurrence dans « Le Langage C++, 3è édition » de Bjarne Stroustrup ?

  • Modèle mémoire et courses de données : Le livre explique le modèle mémoire de C++ et l’importance d’éviter les courses de données, et détaille le fonctionnement des opérations atomiques et des primitives de synchronisation.
  • Abstractions des threads et des tâches : Il traite de la création, de la jonction et du détachement des threads, ainsi que du stockage local aux threads, mais recommande des abstractions de niveau supérieur comme les futures, les promesses et async() pour une concurrence plus sûre.
  • Mutex et variables de condition : Les types de mutex et les enveloppes RAII telles que lock_guard et unique_lock sont présentés pour assurer un verrouillage sûr, ainsi que les variables de condition pour la communication entre threads.
  • Bonnes pratiques : Stroustrup recommande de garder la concurrence simple, d’utiliser les fonctionnalités standard et de raisonner en termes de tâches plutôt que de threads de bas niveau.

8. Comment « Le Langage C++, 3è édition » de Bjarne Stroustrup explique-t-il les modèles, la programmation générique et la métaprogrammation ?

  • Modèles pour le polymorphisme à la compilation : Les modèles permettent d’écrire du code générique qui fonctionne avec tout type répondant à certaines exigences, favorisant la réutilisation et l’efficacité.
  • Concepts et contraintes : Le livre explique comment exprimer sous forme de concepts les exigences imposées aux arguments des modèles, et comment utiliser static_assert et enable_if pour faire respecter les contraintes et améliorer les messages d’erreur.
  • Métaprogrammation à l’aide de modèles : Il présente les calculs à la compilation réalisés au moyen de modèles, tels que les fonctions de types, les prédicats de types et les traits, afin d’améliorer la sûreté des types et les performances.
  • Modèles variadiques : Ils permettent aux fonctions et aux classes d’accepter un nombre arbitraire d’arguments, et prennent en charge des techniques avancées comme un printf sûr du point de vue des types et les tuples.

9. Quels conseils Bjarne Stroustrup donne-t-il sur les classes, l’héritage et le polymorphisme dans « Le Langage C++, 3è édition » ?

  • Les classes comme types définis par l’utilisateur : Les classes encapsulent les données et le comportement, et prennent en charge les constructeurs, les destructeurs et la surcharge des opérateurs pour créer des abstractions robustes.
  • Héritage et contrôle d’accès : Les classes dérivées héritent des classes de base ; des restrictions d’accès permettent de préserver l’encapsulation et de favoriser la réutilisation du code.
  • Fonctions virtuelles et polymorphisme : Les fonctions virtuelles permettent le polymorphisme à l’exécution et la sélection de la fonction appropriée en fonction du type réel de l’objet ; les destructeurs virtuels garantissent un nettoyage correct.
  • Héritage d’interface et héritage d’implémentation : Le livre distingue l’héritage d’interface (classes abstraites) de l’héritage d’implémentation et recommande de les séparer pour favoriser la flexibilité et la facilité de maintenance.

10. Comment « Le Langage C++, 3è édition » de Bjarne Stroustrup traite-t-il de la bibliothèque standard C++, notamment des conteneurs et des algorithmes ?

  • Catégories de conteneurs : Le livre détaille les conteneurs séquentiels (vector, list, deque), les conteneurs associatifs (map, set, unordered_map) et les adaptateurs (stack, queue), et recommande vector par défaut.
  • Algorithmes et itérateurs : Les algorithmes de la STL opèrent sur des paires d’itérateurs, favorisant la programmation générique et le code indépendant des conteneurs ; les catégories d’itérateurs influent sur l’efficacité des algorithmes.
  • Pointeurs intelligents et gestion des ressources : Les pointeurs intelligents standard (unique_ptr, shared_ptr, weak_ptr) sont présentés pour assurer une gestion sûre et automatique des ressources.
  • Chaînes de caractères et entrées-sorties : std::string et les flux d’entrées-sorties sont présentés comme des solutions plus sûres et plus flexibles que les chaînes et les entrées-sorties à la manière de C, avec la prise en charge du formatage, des paramètres régionaux et des types définis par l’utilisateur.

11. Quels conseils Bjarne Stroustrup donne-t-il pour gérer les erreurs, les exceptions et écrire du code robuste dans « Le Langage C++, 3è édition » ?

  • Exceptions pour la propagation des erreurs : Le livre recommande d’utiliser les exceptions pour signaler les erreurs, afin de permettre une gestion structurée des erreurs et leur traitement.
  • RAII pour la sécurité face aux exceptions : La gestion des ressources par RAII garantit leur libération même lorsque des exceptions se produisent, évitant ainsi les fuites.
  • Garanties de sécurité face aux exceptions : Stroustrup distingue les garanties de base, forte et sans exception, et encourage les conceptions qui préservent la validité de l’état du programme en cas d’exception.
  • Limiter les blocs try : Il recommande de garder les blocs try aussi petits que possible et d’intercepter les exceptions par référence, en laissant main() gérer celles qui ne sont pas interceptées afin de préserver la stabilité du programme.

12. Comment « Le Langage C++, 3è édition » de Bjarne Stroustrup traite-t-il de la compatibilité avec C et des bonnes pratiques du C++ moderne ?

  • C++ comme surensemble : Le livre explique que C++ est en grande partie un surensemble de C, mais qu’il offre une vérification des types plus stricte et comporte certaines incompatibilités.
  • Portage et coexistence : Il donne des conseils pour porter du code, utiliser extern "C" pour l’interopérabilité et écrire dans le sous-ensemble commun lorsque c’est nécessaire.
  • Éviter les fonctionnalités obsolètes : Stroustrup met en garde contre l’utilisation de fonctionnalités obsolètes telles que auto_ptr et les spécifications d’exceptions de C++98, et recommande des solutions modernes.
  • Adopter le C++ moderne : Le livre encourage l’utilisation des conteneurs standard, des pointeurs intelligents et des fonctionnalités du langage pour produire un code plus sûr, plus facile à maintenir et portable.

À propos de l'auteur

Bjarne Stroustrup est un informaticien danois surtout connu pour avoir créé le langage de programmation C++. Il a conçu C++ en 1979 alors qu’il travaillait chez Bell Labs, avec l’objectif d’enrichir C de fonctionnalités destinées à la programmation à grande échelle. Stroustrup a joué un rôle crucial dans l’évolution du langage : il a rédigé plusieurs éditions de « Le Langage C++, 3è édition » et contribué à la norme ISO C++. Il a reçu de nombreuses distinctions pour son travail, dont le Computer Entrepreneur Award de l’IEEE Computer Society. Il a occupé des postes à Texas A&M University et à Columbia University, et continue d’influencer l’informatique et la conception des langages de programmation.

Télécharger le PDF

Pour garder le résumé de Le Langage C++, 3è édition pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Le Langage C++, 3è édition sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...