• Aide
  • Eurêkoi Eurêkoi
Langage C++ : de l'héritage C au C++ moderne : avec programmes d'illustration
Livre Langage C++ : de l'héritage C au C++ moderne : avec programmes d'illustration

par Drouillon, Frédéric

Éditions ENI

-

  • Disponible - 681.229 DRO

    Niveau 3 - Informatique

Livre

Langage C++ : de l'héritage C au C++ moderne : avec programmes d'illustration

Auteur(s) : Drouillon, Frédéric Découvrir l'auteur

Résumé

Une approche des langages C+ et C++ fondée sur les notions d'union et d'héritage entre ces deux langages de programmation. Avec la version numérique et des éléments complémentaires à télécharger sur le site de l'éditeur.

  • Éditeur(s)
  • Date
    • C 2023
  • Notes
    • La couv. porte en plus : "En téléchargement : le code source" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an"
    • La 4e de couv. indique : "Sur www.editions-eni.fr : le code source des programmes d'illustration"
    • Contient un "flshcode" permettant d'accéder à un contenu via Internet
  • Langues
    • Français
  • Description matérielle
    • 1 vol. (866 p.) : ill. ; 22 cm
  • Collections
  • Sujet(s)
  • ISBN
    • 978-2-409-03893-8
  • Indice
  • Quatrième de couverture

    • Langage C++

      De l'héritage C au C++ moderne

      Le C++ fascine par l'infini des réalisations et des manières de programmer qu'il permet. D'une part, il hérite du langage C qui lui procure une base pour tout ce qui concerne l'écriture algorithmique, et d'autre part il est doté de puissants outils de structuration orientés objet.

      Ce livre s'adresse aux personnes qui débutent en programmation avec le langage C++ ou ayant déjà programmé dans d'autres langages. Il tient compte des dernières évolutions de C++ et éclaircit la complexité du langage par une exploration systématique de ses composantes natives (algorithmique fondamentale, programmation objet, généricité) auxquelles sont ajoutés quelques éléments sélectionnés parmi les bibliothèques standards (smart pointers ou pointeurs intelligents, conteneurs et contrôle d'erreur avec les exceptions).

      La progression pédagogique de l'auteur se déroule en quatre temps.

      L'auteur commence par traiter de notions qui concernent l'écriture algorithmique et ses fondamentaux : variables, opérations, structures de contrôle (if, switch, boucles, fonctions, attributs). Dans un second temps, le lecteur bascule vers la programmation objet avec les structures et les classes puis il se concentre sur la généricité, les bibliothèques personnelles, les modules et les espaces de noms. Ensuite, l'étude des pointeurs, introduite avec les tableaux et les chaînes de caractères, est développée d'abord avec les pointeurs classiques puis avec les pointeurs-objets dits smart pointers. La quatrième et dernière étape vient compléter l'arsenal des outils natifs de la programmation objet avec les concepts d'héritage, de polymorphisme, de virtualité, de classes abstraites et d'interfaces. Pour finir, le livre s'achève sur la gestion des erreurs.

      Tout au long du livre, l'auteur fournit des exemples de programmes apportant la mise en pratique nécessaire pour s'approprier le langage. Tous les programmes sont en téléchargement sur le site .


  • Tables des matières

      • Langage C++

      • De l'héritage C au C++ moderne (avec programmes d'illustration)

      • 2e édition

      • Editions ENI

      • Introduction
      • 1. L'univers C++25
      • 2. Cartographie pédagogique de la grammaire C++26
      • 3. Organisation du livre27
      • 4. Public visé28
      • 5. Clés pour apprendre28
      • 6. Documentations, versions, environnements30
      • Partie 1 : Fondamentaux algorithmiques
      • Chapitre 1-1
      • Premiers programmes
      • 1. C inclus en C++33
      • 2. Premiers programmes35
      • 2.1 La fonction main() : entrée du programme35
      • 2.2 « Hello world ! » en C36
      • 2.3 "Hello world !" en C++37
      • 3. Bibliothèques, espaces de noms, instruction using38
      • 3.1 Bibliothèque <iostream>, directive #include38
      • 3.2 Espace de noms et instruction using39
      • 3.3 L'espace de noms standard std41
      • 3.4 Inclusion de bibliothèques C en C++42
      • 4. Activer C++2042
      • Chapitre 1-2
      • Variables simples
      • 1. Introduction45
      • 2. Hérité du C46
      • 2.1 Différents types de variables46
      • 2.2 Déclaration des variables48
      • 2.3 Affecter et afficher une valeur49
      • 2.4 Opérateur sizeof50
      • 2.5 Préfixes 0b, 0x, 0 et séparateur (')51
      • 2.6 Suffixes L, LL et f52
      • 2.7 Caractères, codage ASCII53
      • 2.8 Renommer des types avec typedef54
      • 3. Apports du C++55
      • 3.1 Initialisations des variables55
      • 3.2 Type auto57
      • 3.3 Opérateur decltype58
      • 3.4 Opérateur typeid, bibliothèque <typeinfo>59
      • Chapitre 1-3
      • Constantes
      • 1. Constantes const et constexpr61
      • 1.1 Hérité du C61
      • 1.2 Apports du C++62
      • 1.2.1 Plus de rigueur sur const62
      • 1.2.2 Valeurs constantes définies à la compilation : mot-clé constexpr63
      • 2. Énumérations : créations de types enum65
      • 2.1 Hérité du C65
      • 2.2 Apports C++66
      • 3. Directive macroprocesseur #define68
      • Chapitre 1-4
      • Affichage et saisie console
      • 1. Hérité du C71
      • 1.1 Affichage : fonction printf71
      • 1.1.1 Chaînes de caractères71
      • 1.1.2 Convertir des valeurs en caractères avec des formats72
      • 1.1.3 Paramétrer l'affichage de printf74
      • 1.2 Formatage : fonctions sprintf, snprintf, sprintf_s, snprintf_s75
      • 1.3 Saisie de valeurs : fonctions scanf, scanf_s76
      • 2. Apports C++78
      • 2.1 Utiliser coût et cin78
      • 2.1.1 Écrire dans la console avec cout78
      • 2.1.2 Entrer des valeurs avec cin79
      • 2.1.3 Contrôle d'erreur simple81
      • 2.2 Instructions de formatage en sortie86
      • 2.2.1 Afficher des valeurs booléennes86
      • 2.2.2 Largeur minimum de l'affichage87
      • 2.2.3 Alignement des sorties87
      • 2.2.4 Choisir un caractère de remplissage89
      • 2.2.5 Afficher ou non les zéros après la virgule90
      • 2.2.6 Afficher le signe des nombres positifs91
      • Chapitre 1-5
      • Opérations
      • 1. Hérité du C93
      • 1.1 Notion d'expression93
      • 1.2 Opérations arithmétiques94
      • 1.3 Valeurs aléatoires95
      • 1.3.1 Avoir des suites différentes96
      • 1.3.2 Définir une fourchette97
      • 1.4 Opérations bit à bit97
      • 1.4.1 ET : opérateur &97
      • 1.4.2 OU exclusif : opérateur ^99
      • 1.4.3 OU inclusif : opérateur |99
      • 1.4.4 Complément : opérateur ~100
      • 1.4.5 Décalages gauche et droite : opérateurs >> et <<100
      • 1.4.6 Priorités des opérateurs bit à bit100
      • 2. Apports C++101
      • 2.1 Surcharger les opérateurs101
      • 2.2 La bibliothèque <random>101
      • Chapitre 1-6
      • Conversions de types
      • 1. Hérité du C105
      • 1.1 Le principe105
      • 1.2 Opérateur de conversion107
      • 1.3 Exemple : nombre aléatoire avec décimales107
      • 2. Apports du C++108
      • 2.1 static_cast<type>109
      • 2.2 const_cast<type>110
      • 2.3 reinterpret_cast<type>110
      • 2.4 dynamic_cast<type>112
      • Chapitre 1-7
      • Structures de contrôle
      • 1. Hérité du C113
      • 1.1 Bloc d'instructions114
      • 1.2 L'instruction conditionnelle if114
      • 1.3 Définir une condition116
      • 1.3.1 Opérateurs de comparaisons116
      • 1.3.2 L'opérateur unaire NON : !117
      • 1.4 Le couple d'instructions if-else117
      • 1.5 La forme contractée du if-else, opérateur conditionnel "?"119
      • 1.6 La cascade d'instructions if - else if - else120
      • 1.7 Les tests multiconditions (ET/OU)121
      • 1.7.1 Conjonction ET : opérateur &&121
      • 1.7.2 ET avec plus de deux expressions membres122
      • 1.7.3 Disjonction OU, opérateur | |124
      • 1.7.4 OU avec plus de deux expressions membres125
      • 1.7.5 ET prioritaire sur OU126
      • 1.8 Branchement : switch126
      • 1.9 Rupture de séquence : goto avec étiquette129
      • 1.10 Les trois boucles : while, do-while et for130
      • 1.10.1 Boucle TANT QUE : le whrle130
      • 1.10.2 Boucle FAIRE {...} TANT QUE : le do-while132
      • 1.10.3 Boucle comptée POUR : le for133
      • 1.10.4 Boucles imbriquées135
      • 1.11 Sortie et saut forcés dans une boucle136
      • 1.11.1 Sortir avec l'instruction break136
      • 1.11.2 Passer à l'itération suivante avec l'instruction continue137
      • 1.11.3 Sortir d'une ou de plusieurs boucles imbriquées avec l'instruction goto137
      • 2. Apports du C++138
      • 2.1 Condition if ou else-if marquée constexpr138
      • 2.2 Boucle for ( : ) "pour chaque"139
      • Chapitre 1-8
      • Fonctions
      • 1. Hérité du C141
      • 1.1 Principe141
      • 1.2 Fonction sans retour et sans paramètre143
      • 1.3 Déclaration et visibilité d'une fonction144
      • 1.4 Fonctions avec paramètres146
      • 1.4.1 Copie de valeurs et passage par valeur146
      • 1.4.2 Déplacer le curseur en écriture de la fenêtre console147
      • 1.4.3 Changer la couleur des caractères150
      • 1.4.4 À propos de la couleur en console151
      • 1.4.5 Afficher une lettre à une position et d'une couleur donnée dans la console152
      • 1.4.6 Tracer une ligne horizontale153
      • 1.4.7 Le programme complet154
      • 1.5 Fonctions avec retour155
      • 1.5.1 Retourner un nombre aléatoire entre 0 et 1155
      • 1.5.2 Retourner le résultat d'un jeté de deux dés à six faces156
      • 1.5.3 Programme complet156
      • 1.5.4 Types des valeurs de retour157
      • 1.6 Fonctions avec retour et avec paramètres158
      • 1.6.1 Conversion en chiffres romains158
      • 1.7 Fonction et qualificatif static162
      • 1.7.1 Qualificatif static et fonctions162
      • 1.8 Fonctions récursives164
      • 1.9 Nommer les fonctions165
      • 1.9.1 Contraintes syntaxiques165
      • 1.9.2 Sens des noms choisis166
      • 1.9.3 Normes et styles pour la mise en forme du code source166
      • 2. Apports du C++167
      • 2.1 Fonctions embarquées "inline"167
      • 2.2 Fonctions constantes marquées constexpr168
      • 2.3 Fonctions marquées const170
      • 2.4 Fonctions déclarées noexcept171
      • 2.5 Valeurs par défaut de paramètres171
      • 2.6 Surcharge des fonctions173
      • 2.7 Références et passage par référence174
      • 2.8 Expression lambda (fonction anonyme)176
      • 2.8.1 Principe176
      • 2.8.2 Syntaxe générale177
      • 2.8.3 Les clauses de capture179
      • 2.8.4 Clauses de capture multiples181
      • 2.8.5 Spécification mutable182
      • 2.8.6 Listes de paramètres183
      • 2.8.7 Spécification d'une exception183
      • 2.8.8 Le type de retour184
      • 2.8.9 Lambda constexpr186
      • 2.8.10 Récupérer une lambda et appels possibles187
      • 2.8.11 Quelques précisions188
      • 2.9 Fonction operator et surcharge des opérateurs191
      • 2.10 Fonctions génériques (template, auto)191
      • Chapitre 1-9
      • Précisions sur les variables, attributs
      • 1. Précisions sur les variables193
      • 1.1 Visibilité et durée de vie d'une variable193
      • 1.2 Masquage d'une variable195
      • 1.3 Variable static197
      • 2. Attributs198
      • 2.1 Principe et syntaxe198
      • 2.2 Exemples d'utilisation200
      • 2.2.1 Expérimentation GNU200
      • 2.2.2 Expérimentation GSL Microsoft200
      • 2.3 Attributs standards204
      • 2.3.1 [[noreturn]] (depuis C++11)204
      • 2.3.2 [[fallthrough]] (depuis C++17)205
      • 2.3.3 [[deprecated]], [[deprecated("reason")]] (depuis C++14)207
      • 2.3.4 [[nodiscard]] (depuis C++17) [[nodiscard("reason")]] (depuis C++20)208
      • 2.3.5 [[maybe_unused]] (depuis C+H-17)208
      • 2.3.6 [[likely]] et [[unlikely]] (depuis C++20)209
      • 2.3.7 [[no_unique_address]] (depuis C++20)210
      • Chapitre 1-10
      • Structures et classes
      • 1. Hérité du C213
      • 1.1 Principe de la structure213
      • 1.2 Disposer d'une structure214
      • 1.2.1 Définir un type de structure214
      • 1.2.2 Déclarer une variable structure214
      • 1.2.3 Initialiser à la déclaration215
      • 1.2.4 Accéder aux éléments avec l'opérateur point216
      • 1.2.5 Copier deux structures216
      • 1.3 Structures et fonctions216
      • 1.3.1 Fonction d'initialisation d'une entité217
      • 1.3.2 Fonctions d'affichage et d'effacement217
      • 1.3.3 Fonction pour avancer.218
      • 1.3.4 Boucle événementielle219
      • 1.3.5 Contrôle du rythme dé l'animation220
      • 1.3.6 Rendre invisible le curseur en écriture221
      • 1.3.7 Démo entité mobile222
      • 1.4 Structures imbriquées225
      • 2. Apports du C++ : la structure devient une classe226
      • Partie 2 : Entrée en territoire Objet
      • Chapitre 2-1
      • Classes
      • 1. De la structure à la classe227
      • 1.1 Des droits d'accès : public, protected, private228
      • 1.2 Des fonctions membres231
      • 1.2.1 Cas général231
      • 1.2.2 Fonctions membres déclarées const232
      • 1.3 Une initialisation renforcée233
      • 1.3.1 Initialisations à la déclaration233
      • 1.3.2 Initialisations par défaut dans la classe234
      • 1.4 Des constructeurs et des initialiseurs235
      • 1.4.1 Initialiser avec des constructeurs235
      • 1.4.2 Constructeur par défaut236
      • 1.4.3 Initialisations contraintes par les constructeurs existants237
      • 1.4.4 Constructeurs avec initialiseurs238
      • 1.4.5 L'initialiseur initialise les constantes239
      • 1.5 Le pointeur this240
      • 1.6 Un programme C muté objet C+242
      • 1.6.1 Réécriture des entités mobiles242
      • 1.6.2 Amélioration du programme248
      • 1.7 Que dire des structures en C++ ?253
      • 1.7.1 Des aspects pratiques253
      • 1.7.2 Réfléchir l'interface des objets254
      • 2. Accesseurs (property en anglais)254
      • 2.1 Lire une variable private ou protected255
      • 2.2 Modifier une variable private ou protected256
      • 2.3 Intérêt d'un appel de fonction256
      • 3. Qualificatif static dans une classe259
      • 4. default et delete pour les fonctions spéciales de classe260
      • 4.1 Fonctions spéciales260
      • 4.2 Utiliser default (rappel et précision)261
      • 4.3 Utiliser delete263
      • 5. Surcharge des opérateurs264
      • 5.1 Principe264
      • 5.2 Fonction operator hors classe265
      • 5.2.1 Exemple addition : operator +265
      • 5.2.2 Exemple décalage à gauche : operator <<266
      • 5.3 Fonction operator dans une classe269
      • 5.3.1 operator+ sans retour269
      • 5.3.2 operator+ avec retour de l'objet courant (*this)270
      • 5.3.3 opérator+ avec retour d'un nouvel objet résultant272
      • 5.4 Transformer un objet en une fonction (objet fonction ou fonction objet)273
      • 5.5 Utiliser l'opérateur bool275
      • 6. L'instruction friend ("ami")276
      • Chapitre 2-2
      • Unions, unions illimitées
      • 1. Principe279
      • 2. Union de structures282
      • 3. Union discriminée283
      • 4. Union illimitée (C++11)287
      • Chapitre 2-3
      • Généricité, template, auto
      • 1. Principe du template291
      • 2. Template de fonction292
      • 2.1 Définir une fonction générique292
      • 2.2 Fonction avec plusieurs types génériques294
      • 2.3 Evaluation des types génériques à la compilation295
      • 2.4 Expressions lambda et template297
      • 2.5 Template pour passer des valeurs298
      • 3. Template de classe300
      • 3.1 Syntaxe300
      • 3.1.1 Syntaxe générale300
      • 3.1.2 Syntaxe des constructeurs301
      • 3.1.3 Syntaxe avec plusieurs types génériques302
      • 3.1.4 Déduction de type à l'initialisation302
      • 3.1.5 Types par défaut303
      • 3.1.6 L'instance du template influence le type de la classe304
      • 3.2 Paramétrages305
      • 3.2.1 Paramétrage avec des valeurs305
      • 3.2.2 Template en paramètre de template308
      • 3.2.3 Spécialiser une fonction pour un type donné310
      • 3.2.4 Spécialiser une classe complète312
      • 3.2.5 Spécialiser une classe avec plusieurs types génériques314
      • 3.2.6 Paramétrage avec des objets fonctions316
      • 4. Template variadique et paquet de paramètres317
      • 4.1 Principe : l'opérateur variadique (...)317
      • 4.2 Template variadique de fonction320
      • 4.2.1 Cas général320
      • 4.2.2 Itérations simplifiées (fold expression, C++17)322
      • 4.2.3 Deux paramètres variadiques323
      • 4.3 Template variadique de classe326
      • 5. Utilités standards à base de templates327
      • 5.1 La classe bitset328
      • 5.2 La classe tuple<...>329
      • 5.3 La classe pair<>333
      • 5.4 Alternatives à l'union336
      • 5.4.1 La classe variant336
      • 5.4.2 La classe optional339
      • 5.4.3 La classe any341
      • 5.5 La classe std : :function<>343
      • 6. Concepts (C++20)344
      • 6.1 Définir un concept345
      • 6.2 L'expression requires348
      • 6.2.1 Exemple d'utilisation sans paramètre348
      • 6.2.2 Exemple d'utilisation avec paramètres350
      • 6.3 Etablir des contraintes351
      • 6.3.1 Conjonction ET (&&)352
      • 6.3.2 Disjonction OU (| |)354
      • 7. Spécification auto356
      • 7.1 Principes généraux356
      • 7.1.1 Variables simples auto356
      • 7.1.2 Listes auto359
      • 7.2 Templates et auto360
      • 7.2.1 Spécification decltype(auto)360
      • 7.2.2 Comparaison entre auto et template362
      • 7.2.3 Utilisation de auto dans un template363
      • Chapitre 2-4
      • Bibliothèques, modules et espaces de noms
      • 1. Créer une bibliothèque classique (.h)367
      • 1.1 Contenu du fichier outils.h370
      • 1.2 Contenu du fichier outils.cpp371
      • 1.3 Contenu du fichier main.cpp372
      • 1.4 Problèmes de redéfinitions, instruction extern375
      • 2. Espaces de noms (namespace)377
      • 2.1 Cartographier du code377
      • 2.2 Accéder au contenu378
      • 2.3 Répartition sur plusieurs fichiers379
      • 2.3.1 Espace de noms dans une bibliothèque380
      • 2.3.2 Espace de noms réparti entre plusieurs fichiers381
      • 2.3.3 Espace de noms ToutpourlesChiens réorganisé385
      • 2.4 Imbriquer des espaces de noms387
      • 2.5 Espaces de noms inline388
      • 2.6 Espace de noms anonymes391
      • 2.7 Remplacer un nom trop long par un alias392
      • 3. La directive using392
      • 3.1 Faciliter l'accès à un espace de noms392
      • 3.2 Constituer un alias de type395
      • 4. Modules (C++20)397
      • 4.1 Principe397
      • 4.2 Créer une unité d'interface de module (.ixx)398
      • 4.3 Définir le contenu du module400
      • 4.4 Importer le module dans un fichier source401
      • 4.5 Utiliser des bibliothèques standards dans un module402
      • 4.6 Utiliser une bibliothèque personnelle dans un module405
      • 4.7 Éléments non exportables dans un module405
      • 4.8 Partitionner un module406
      • 4.9 Espaces de noms dans un module410
      • 4.10 Créer un fichier d'implémentation de module412
      • 4.11 Création d'un module Outils (version 1)414
      • 4.12 Création d'un module Outils (version 2)416
      • 4.13 Modules ou bibliothèques ?417
      • 5. Précision sur la liaison entre C++ et C418
      • Partie 3 : Puissance du pointeur et gestion de la mémoire
      • Chapitre 3-1
      • Tableaux statiques, introduction conteneurs
      • 1. Hérité du C421
      • 1.1 Principe du tableau421
      • 1.2 Disposer d'un tableau422
      • 1.2.1 Définir et déclarer un tableau422
      • 1.2.2 Des constantes pour les tailles423
      • 1.2.3 Accéder aux éléments du tableau avec l'opérateur [ ]423
      • 1.2.4 Débordement de tableau425
      • 1.2.5 Parcourir un tableau avec une boucle for425
      • 1.2.6 Initialiser un tableau à la déclaration428
      • 1.3 Tableaux à plusieurs dimensions430
      • 1.3.1 Matrice à deux dimensions430
      • 1.3.2 Tableaux à n dimensions431
      • 1.3.3 Initialiser à la déclaration432
      • 1.3.4 Parcourir un tableau à plusieurs dimensions432
      • 1.4 Tableaux en paramètre de fonctions433
      • 2. Apports du C++434
      • 2.1 Boucle for ( : ) "pour chaque"434
      • 2.2 Récupérer une liste variadique d'éléments dans un tableau statique436
      • 2.3 Tableaux d'objets, exemple fourmilière (version 1)438
      • 2.4 Tableau dans une classe, fourmilière (version 2)443
      • 2.4.1 Paramétrer la classe443
      • 2.4.2 La classe fourmilière444
      • 2.5 Tableau dans une classe, exemple pile générique446
      • 2.5.1 Création de la pile446
      • 2.5.2 Tri paramétrable de la pile (objet fonction)448
      • 2.5.3 Spécialisation sur un type452
      • 3. Introduction des conteneurs454
      • 3.1 La classe array455
      • 3.2 La classe vector457
      • 3.3 La classe list460
      • 3.4 Contenus variadiques463
      • 3.5 Boucle for_each de la bibliothèque <algorithm>465
      • Chapitre 3-2
      • Chaînes de caractères, la classe string
      • 1. Hérité du C469
      • 2. Apports du C++ : la classe string472
      • Chapitre 3-3
      • Pointeurs
      • 1. Principes généraux475
      • 1.1 Adresse et mémoire475
      • 1.2 Une variable pointeur477
      • 1.3 Quatre opérateurs dédiés479
      • 1.4 Cinq utilisations classiques479
      • 2. Hérité du C481
      • 2.1 Déclarer un pointeur dans un programme481
      • 2.2 Opérateur adresse : &482
      • 2.3 Opérateur étoile : *483
      • 2.4 Opérateur flèche : ->484
      • 2.5 Opérateur crochets : [ ]486
      • 2.6 Priorité des quatre opérateurs487
      • 2.7 Pointeurs et constantes487
      • 2.7.1 Pointeur variable sur un objet constant487
      • 2.7.2 Pointeur constant sur un objet variable488
      • 2.7.3 Pointeur constant sur un objet constant489
      • 2.8 Le pointeur générique void*490
      • 2.9 Pointeurs de fonction491
      • 2.9.1 Une fonction est une adresse491
      • 2.9.2 Reconnaître le type d'une fonction492
      • 2.9.3 Appeler une fonction via un pointeur du bon type493
      • 2.9.4 Cast nécessaire si le pointeur est un void*493
      • 2.9.5 Pourquoi des pointeurs de fonction ? Les « callbacks »494
      • 3. Apports du C++497
      • 3.1 Un souci de rigueur497
      • 3.1.1 Plus de rigueur497
      • 3.2 Opérateurs new et delete, new[ ] et delete[ ]499
      • 3.2.1 Principe499
      • 3.2.2 Respecter les couples new-delete et new[]-delete[]501
      • 3.2.3 Allocation d'un tableau de 0 élément ?!501
      • 3.2.4 Précisions sur l'opérateur new503
      • 3.3 La valeur nullptr508
      • 3.4 Type référence & (pointeur constant et simplifié)510
      • 3.4.1 Principe510
      • 3.4.2 Une référence est constante513
      • 3.4.3 Référence déclarée const513
      • 3.4.4 Connaître la valeur de la référence514
      • 3.5 Retourner une référence515
      • 3.5.1 Piège à éviter516
      • 3.5.2 Masquer un tableau avec une fonction517
      • 3.6 Type référence && (Right value)518
      • 3.6.1 Des catégories d'expressions518
      • 3.6.2 lvalues (objets persistants) et rvalues (objets temporaires)519
      • 3.6.3 Affectations d'objets temporaires rvalues521
      • 3.6.4 Objets rvalues passés en paramètre de fonction524
      • 3.6.5 Remarque : une ambigüité possible526
      • 3.6.6 Déclarateur de référence rvalue : &&527
      • 3.6.7 Référence rvalue && en paramètre de fonction529
      • 3.6.8 Référence rvalue && en paramètre de constructeur530
      • 3.7 Conversions en rvalue531
      • 3.7.1 Un static_cast<>531
      • 3.7.2 La fonction de déplacement std : :move532
      • 3.7.3 La fonction de transfert std : :forward<>534
      • 3.7.4 Situation de conversion implicite de rvalue(&&) à Ivalue (&)538
      • 3.7.5 Liste variadique et transfert parfait540
      • 3.8 Spécificateur decltype et références541
      • Chapitre 3-4
      • Pointeurs et références dans la classe
      • 1. Introduction547
      • 2. Le destructeur548
      • 2.1 Les éléments non dynamiques s'autodétruisent (rappel)548
      • 2.2 Problème des éléments dynamiques perdus en mémoire549
      • 2.3 Écrire un destructeur des éléments dynamiques550
      • 2.4 Appels explicites du destructeur552
      • 2.5 Destructeur appelé avec delete554
      • 3. Constructeur de copie558
      • 3.1 Principe558
      • 3.2 Copier un objet à la déclaration558
      • 3.3 Copier des objets possédant des données dynamiques559
      • 3.3.1 Problème des données dynamiques559
      • 3.3.2 Interdire la copie561
      • 3.3.3 Implémenter un constructeur de copie561
      • 4. Constructeur de déplacement564
      • 4.1 Principe565
      • 4.2 Possible avertissement noexcept567
      • 4.3 Constructeur de déplacement avec données dynamiques568
      • 5. Surcharge des opérateurs et données dynamiques573
      • 5.1 Affectation de copie (operator=)573
      • 5.2 Affectation de déplacement (move)579
      • 5.3 Surcharge operator+584
      • 6. Questions diverses586
      • 6.1 Spécialiser une classe générique en pointeur586
      • 6.2 Créer un singleton588
      • 6.3 Références dans une classe590
      • Chapitre 3-5
      • Pointeurs-objets ou "smart pointers"
      • 1. Introduction593
      • 1.1 La bibliothèque memory593
      • 1.2 Transformer un pointeur en objet594
      • 2. La classe std::unique_ptr597
      • 2.1 Expérimentation du pointeur unique597
      • 2.2 Survol du contenu principal599
      • 2.2.1 Constructeurs599
      • 2.2.2 Destructeur600
      • 2.2.3 Six surcharges d'opérateurs602
      • 2.2.4 Cinq fonctions membres605
      • 2.2.5 Quatre fonctions hors classe607
      • 3. La classe std::shared_ptr608
      • 3.1 Expérimentation du pointeur partagé609
      • 3.2 Survol du contenu principal611
      • 3.2.1 Constructeurs611
      • 3.2.2 Destructeur613
      • 3.2.3 Six surcharges d'opérateurs616
      • 3.2.4 Cinq fonctions membres619
      • 3.2.5 Fonctions hors classe623
      • 3.2.6 Fonctions hors classe de conversion629
      • 4. La classe std::weak_ptr638
      • 4.1 Expérimentation du pointeur "simple observateur"638
      • 4.2 Survol du contenu principal640
      • 4.2.1 Constructeurs640
      • 4.2.2 Destructeur643
      • 4.2.3 Six fonctions membres644
      • 4.2.4 Surcharge opérateur =649
      • 5. Allocateur de mémoire : la classe std::allocator651
      • Chapitre 3-6
      • Pointeurs, utilisations classiques
      • 1. Introduction655
      • 2. Pointeur en paramètre (passage par référence)655
      • 2.1 Expérimentation avec pointeur classique656
      • 2.2 Simplification de l'écriture avec des références C++657
      • 2.3 Tableau en paramètre658
      • 2.3.1 Tableau à une dimension658
      • 2.3.2 Tableaux à plusieurs dimensions660
      • 3. Allocation dynamique et tableaux661
      • 3.1 Tableau de pointeurs661
      • 3.2 Allocation d'un tableau à une dimension663
      • 3.3 Allocation d'un tableau à plusieurs dimensions664
      • 3.3.1 Allocation d'une matrice de int664
      • 3.3.2 Allocation d'une forme à six dimensions de points666
      • 3.4 Quelques pièges classiques de l'allocation dynamique669
      • 4. Relier des objets670
      • 4.1 Associer deux types structures style C671
      • 4.1.1 Structures Avion et Pilote671
      • 4.1.2 Avion ou pilote existent-ils ?672
      • 4.1.3 Avion ou pilote sont-ils libres ?672
      • 4.1.4 Relier avion et pilote673
      • 4.1.5 Délier un avion et un pilote673
      • 4.1.6 Constructeurs Avion et Pilote674
      • 4.1.7 Afficher Avion et Pilote675
      • 4.1.8 Détruire un Avion ou un Pilote676
      • 4.1.9 Code complet, main action676
      • 4.2 Associer des classes de même type681
      • 4.3 Élaborer une liste, fourmilière (version 3)684
      • Partie 4 : Programmation Orientée Objet (POO)
      • Chapitre 4-1
      • Associations entre classes
      • 1. Introduction693
      • 2. Principes des associations pour les relations entre objets693
      • 2.1 Association simple694
      • 2.2 Agrégation694
      • 2.3 Composition695
      • 2.4 Problème syntaxique en C++695
      • 3. Associations simples : messages entre objets696
      • 3.1 Liaison non réciproque entre deux objets696
      • 3.2 Liaison réciproque entre deux objets698
      • 4. Agrégations : coopération entre objets702
      • 4.1 Liaison à sens unique (exemple guitare, guitariste)702
      • 4.2 Partage d'objets pointés (plusieurs musiciens, une guitare)704
      • 4.2.1 Musiciens simultanés705
      • 4.2.2 Plusieurs musiciens successifs707
      • 5. Liaisons réciproques entre objets709
      • 5.1 Problème de syntaxe709
      • 5.2 Déclaration de type incomplet710
      • 5.3 Limite du type incomplet711
      • 5.4 Résolution du problème712
      • 5.5 Exemple Terminator716
      • 6. Composition : dépendance entre objets718
      • 6.1 Choisir entre agrégation ou composition718
      • 6.2 Techniques envisageables718
      • 6.3 Pointeur d'objet en propriété719
      • 6.4 Objet en propriété721
      • 6.5 Référence d'objet en propriété725
      • Chapitre 4-2
      • Héritage
      • 1. Principe727
      • 2. Définir une classe dérivée728
      • 3. Appeler explicitement un constructeur de la classe de base730
      • 4. Redéfinition de données ou de fonctions731
      • 5. Spécifier un membre de la classe de base733
      • 6. Droits d'accès locaux de la classe héritée734
      • 7. Droits d'accès globaux de la classe héritée737
      • 8. Héritage multiple742
      • 8.1 Principe et syntaxe742
      • 8.2 Exemple : InDominusRex743
      • 8.3 Relations transversales dans un arbre de classes745
      • 8.4 Héritage multiple avec une base virtuelle748
      • 9. Comment identifier un héritage752
      • 9.1 Distinction entre héritage et association752
      • 9.2 Distinction entre attributs et nouvelle classe754
      • Chapitre 4-3
      • Polymorphisme et virtualité
      • 1. Principe755
      • 2. Accès pointeurs limité par son type755
      • 3. Autorisation d'accès pour les fonctions virtuelles757
      • 4. Destructeur virtuel758
      • 5. Intérêt des fonctions virtuelles759
      • Chapitre 4-4
      • Classe abstraite et interface
      • 1. Classe abstraite, fonctions virtuelles pures763
      • 2. Tronc commun pour dériver766
      • 3. Interface770
      • 4. Récupérer une sous classe depuis une base abstraite773
      • 5. Résumé classe abstraite et interface776
      • 6. Expérimentation : exemples des super-héros, les Avengers777
      • 6.1 Classe de base super-héros, interface des fonctions d'action777
      • 6.1.1 Définition et stockage des armes778
      • 6.1.2 Définition et stockage du paramétrage émotionnel779
      • 6.1.3 Interface de fonctions pour tous les super-héros779
      • 6.1.4 Définition de la classe "SuperHeros"780
      • 6.2 Une dérivée pour chaque Avenger782
      • 6.2.1 Classe "CaptainAmerica"783
      • 6.2.2 Classes Hulk, IronMan, BlackWidow et Thor784
      • 6.3 Souhait du polymorphisme et impossibilité787
      • 6.4 Virtualité, intérêt de l'interface des fonctions d'action789
      • 6.5 Classe abstraite792
      • Chapitre 4-5
      • Gestion des erreurs
      • 1. Introduction803
      • 2. Socle hérité du C804
      • 2.1 Retourner un booléen804
      • 2.2 Retourner un numéro d'erreur809
      • 2.3 Afficher des informations au moment de l'erreur811
      • 2.4 Bibliothèques C de contrôle d'erreur815
      • 2.4.1 La bibliothèque <cerrno> (errno.h)816
      • 2.4.2 La bibliothèque <cassert> (assert.h)817
      • 3. Contrôle d'erreur C++819
      • 3.1 Introduction819
      • 3.1.1 Bibliothèques de diagnostics819
      • 3.1.2 Conseil sur les exceptions820
      • 3.2 Instructions natives throw, try et catch821
      • 3.2.1 Retour throw821
      • 3.2.2 Saut try et récupération catch822
      • 3.2.3 Retour throw d'un appel de fonction823
      • 3.2.4 Instruction throw sans valeur de retour826
      • 3.2.5 Bloc catch(...) par défaut826
      • 3.2.6 Exception non gérée827
      • 3.2.7 Fonctions déclarées noexcept829
      • 3.3 L'en-tête <exception>830
      • 3.3.1 Principe830
      • 3.3.2 Classe std : exception833
      • 3.3.3 Les fonctions std::terminate, std::set_terminate ; std::get_terminate837
      • 3.3.4 Utiliser la virtualité de la classe std::exception839
      • 3.4 Déclaration static_assert844
      • Index849

  • Origine de la notice:
    • BPI

  • Disponible - 681.229 DRO

    Niveau 3 - Informatique

Sur le même thème

Programmer efficacement en C++ : 42 conseils pour mieux maîtriser le C++ 11 et le C++ 14

Programmer efficacement
en C++ : 42 […]

Meyers, Scott

C# 8 : développez des applications Windows avec Visual Studio 2019

C# 8 : développez des
applications […]

Hugon, Jérôme

Programmer en C++ moderne : de C++ 11 à C++ 20

Programmer en C++
moderne : de C++ 11[…]

Delannoy, Claude
(1946-....)

CSS3 : pratique du design web

CSS3 : pratique du
design web

Giraudel, Hugo, Goetter,
Raphaël

C# 8 et Visual Studio 2019 : les fondamentaux du langage

C# 8 et Visual Studio
2019 : les […]

Putier, Sébastien

Le guide complet du langage C

Le guide complet du
langage C

Delannoy, Claude
(1946-....)

C++

C++

Pichaud, Christophe

C#

C#

Pichaud, Christophe

Le traitement numérique des images en C++ : implémentation d'algorithmes avec la bibliothèque Clmg

Le traitement numérique
des images en C++ :[…]

Tschumperlé, David
(1976-....), Barra,[…]

C# 9 : développez des applications Windows avec Visual Studio 2019

C# 9 : développez des
applications […]

Hugon, Jérôme

C++ : des fondamentaux du langage aux applications

C++ : des fondamentaux
du langage aux […]

Guérin, Brice-Arnaud

Le guide du C++ moderne : de débutant à développeur

Le guide du C++ moderne
: de débutant à […]

Vittupier, Benoît,
Benharrats, Mehdi

Programmer en C++ : des premiers pas à la maîtrise de C++ 20

Programmer en C++ : des
premiers pas à la […]

Gibaud, Alain
(1956-....)

Design patterns pour C# Sharp : les 23 modèles de conception : descriptions et solutions illustrées en UML 2 et C#

Design patterns pour C#
Sharp : les 23 […]

Debrauwer, Laurent

C# 10 : développez des applications Windows avec Visual Studio 2022

C# 10 : développez des
applications […]

Hugon, Jérôme

Apprendre la programmation orientée objet avec le langage C# : avec exercices pratiques et corrigés

Apprendre la
programmation […]

Gervais, Luc (1964-....)

C# 10 : les fondamentaux

C# 10 : les fondamentaux

Albahari, Joseph,
Albahari, Ben

Maîtrisez Qt : guide de développement d'applications professionnelles

Maîtrisez Qt : guide de
développement […]

Israël, Tristan

Le langage C, norme ANSI

Le langage C, norme ANSI

Kernighan, Brian W.,
Ritchie, Dennis M. […]

Langage C++ : de l'héritage C au C++ moderne : avec programmes d'illustration

Langage C++ : de
l'héritage C au […]

Drouillon, Frédéric

Voir tout les résultats (30)