C++ : des fondamentaux du langage aux applications

Auteur(s) :

Guérin, Brice-Arnaud Découvrir l'auteur

Résumé

Destiné aux développeurs souhaitant apprendre ce langage ou consolider leur expérience professionnelle, cet ouvrage présente les bases de la syntaxe du langage, décrit les notions clés pour créer ses premières applications (tableur graphique, programme de compression de fichiers...), détaille la programmation orientée objet et étudie les mécanismes les plus importants de la STL, entre autres. ©Electre 2021

Éditeur(s)
- Éditions ENI
Date
- C 2021
Notes
- La couv. porte en plus : ""En téléchargement : exemples, code source" ; "Version en ligne offerte pendant 1 an !"
Langues
- Français
Description matérielle
- 1 vol. (480 p.) : ill. ; 22 cm
Collections
- Ressources informatiques
Sujet(s)
- Guides pratiques
- C plus-plus (langage de programmation)
ISBN
- 978-2-409-03020-8
Indice
- 681.229 Langages C
Quatrième de couverture
- C++
  Des fondamentaux du langage aux applications
  Ce livre s'adresse à tout développeur désireux d'apprendre le langage C++, dans le cadre de ses études ou pour consolider son expérience professionnelle.
  Le premier chapitre présente les bases de la syntaxe du langage ainsi que l'organisation des programmes. Le chapitre suivant est une transition vers C++, il explique les notions clés pour créer ses premières applications : structures, pointeurs, bibliothèques standards... Le troisième chapitre dètaille la programmation orientée objet et les mécanismes spécifiques au langage (héritage, modèles de classes...). Vient ensuite l'étude de la STL (Standard Template Library), présentée à travers ses mécanismes les plus importants : les chaînes, les structures de données et les parcours de collection. Les évolutions du C++ moderne telles que les lambda-expressions, les smart-pointers et l'inférence de type sont également étudiées en préalable à la bibliothèque boost. Un chapitre ouvre C++ sur ses univers, tels que l'environnement managé .NET C++ CLI et les applications Win32.
  Comme illustration des capacités de C++ à créer tout type d'applications, l'auteur propose un exemple complet de tableur graphique, un interprète du langage tiny-Lisp ou encore un programme de compression de fichiers.
  L'ouvrage se termine par un chapitre consacré à l'optimisation, aux méthodes de conception orientée objet UML et aux design patterns puis par un chapitre appliquant des algorithmes essentiels en C++ traitant de la reconnaissance de motifs, la recherche dans un graphe et de compression de données.
  Le code source des exemples du livre est disponible en téléchargement sur www.editions-eni.fr. Les exemples sont réalisés avec Visual Studio Community Edition sous Windows et avec Eclipse sous Linux Ubuntu.
Tables des matières
- - C++
  - Des fondamentaux du langage aux applications
  - 3e édition
  - Éditions Eni
  - Avant-propos
  - 1. Objectifs de ce livre13
  - 2. Travaux pratiques14
  - Chapitre 1
  - Introduction
  - 1. Notions clés15
  - 1.1 Principales caractéristiques du langage C+ +15
  - 1.2 Programmation orientée objet17
  - 1.3 Environnement de développement et fichier makefile20
  - 1.3.1 Choix d'un EDI20
  - 1.3.2 Construction d'un fichier makefile21
  - 1.4 Organisation d'un programme C++25
  - 1.4.1 Codes sources26
  - 1.4.2 Modules objets29
  - 1.4.3 Bibliothèques (librairies)32
  - 1.4.4 Exécutable33
  - 1.5 Préprocesseur34
  - 1.6 Choix d'un compilateur35
  - 1.7 Editeur de liens36
  - 2. Bases de la programmation C++36
  - 2.1 Déclaration de variables37
  - 2.1.1 Utilité des variables37
  - 2.1.2 Portée des variables39
  - 2.1.3 Syntaxe de déclaration41
  - 2.1.4 Types de données41
  - 2.2 Instructions de tests et opérateurs50
  - 2.2.1 Instructions de tests50
  - 2.2.2 Opérateurs53
  - 2.3 Instructions de boucle59
  - 2.3.1 La boucle for59
  - 2.3.2 La boucle while61
  - 2.3.3 La boucle do61
  - 2.3.4 Les instructions de débranchement62
  - 2.4 Tableaux62
  - 2.5 Fonctions et prototypes64
  - 2.5.1 Déclaration d'une fonction65
  - 2.5.2 Fonctions et procédures65
  - 2.5.3 Appel des fonctions67
  - 2.5.4 Gestion des variables locales67
  - 2.5.5 Définition de fonctions homonymes (polymorphisme)68
  - 2.5.6 Fonctions à nombre variable d'arguments69
  - 2.5.7 Attribution de valeurs par défaut aux arguments71
  - 2.5.8 Fonctions en ligne72
  - 2.5.9 Fonctions externes de type C72
  - 2.5.10 Fonctions récursives73
  - 2.5.11 La fonction main()74
  - 2.6 Pointeurs76
  - 2.6.1 Pointeurs sur des variables77
  - 2.6.2 Pointeurs et tableaux81
  - 2.6.3 Allocation de mémoire83
  - 2.6.4 Arithmétique des pointeurs86
  - 2.6.5 Pointeurs de pointeurs87
  - 2.6.6 Pointeurs de fonctions88
  - 2.7 Références96
  - 2.8 Constantes9999
  - 2.8.1 Constantes symboliques99
  - 2.8.2 Le type void100
  - 2.8.3 Les alias de type : typedef101
  - 2.8.4 Constantes et énumérations101
  - 3. Exceptions102
  - 3.1 Les approches de bas niveau102
  - 3.1.1 Drapeaux et interruptions102
  - 3.1.2 Traitement des erreurs en langage C104
  - 3.2 Les exceptions plus sûres que les erreurs106
  - 3.3 Propagation explicite107
  - 3.4 Types d'exceptions personnalisés108
  - 3.4.1 Définition de classes d'exception108
  - 3.4.2 Instanciation de classes109
  - 3.4.3 Classes d'exception dérivées110
  - 3.5 Prise en charge d'une exception et relance111
  - 3.6 Exceptions non interceptées112
  - 3.7 Acquisition de ressources112
  - 4. Travaux pratiques115
  - 4.1 Prise en main de l'interprète tiny-lisp115
  - 4.1.1 Structure de la solution115
  - 4.1.2 Le dossier config116
  - 4.1.3 Le dossier framework117
  - 4.1.4 Le dossier jsonlib118
  - 4.1.5 Le dossier langage118
  - 4.1.6 Le dossier modules120
  - 4.1.7 Le dossier scriptboxes121
  - 4.2 Utiliser l'interprète en mode interactif122
  - 4.3 Code de la boucle principale124
  - 4.3.1 La fonction main()124
  - 4.3.2 La boucle eval_loop()125
  - 4.3.3 Utiliser le débogueur127
  - 4.4 Utiliser l'interprète depuis tinylisplab130
  - Chapitre 2
  - De C à C++
  - 1. Programmation structurée133
  - 1.1 Structures134
  - 1.1.1 Constitution d'une structure135
  - 1.1.2 Instanciation de structures136
  - 1.1.3 Instanciation avec l'opérateur new137
  - 1.1.4 Pointeurs et structures138
  - 1.1.5 Organisation de la programmation139
  - 1.2 Unions140
  - 1.3 Copie de structures143
  - 1.4 Création d'alias de types de structures146
  - 1.5 Structures et fonctions146
  - 1.5.1 Passer une structure par valeur comme paramètre147
  - 1.5.2 Passer une structure par référence comme paramètre.147
  - 1.5.3 Passer une structure par adresse comme paramètre148
  - 1.5.4 De la programmation fonctionnelle à la programmation objet148
  - 2. Gestion de la mémoire149
  - 2.1 Alignement des données150
  - 2.2 Allocation de mémoire interprocessus151
  - 3. La bibliothèque standard du C152
  - 3.1 Les fonctions communes du langage C <stdlib.h>152
  - 3.2 Chaînes <string.h>153
  - 3.3 Fichiers <stdio.h>155
  - 4. Travaux pratiques160
  - 4.1 Chargement de scripts dans tiny-lisp160
  - 4.2 Supprimer les erreurs liées à la librairie non sécurisée161
  - Chapitre 3
  - Programmation orientée objet
  - 1. Classes et instances163
  - 1.1 Définition de classe164
  - 1.1.1 Les modificateurs d'accès165
  - 1.1.2 Organisation de la programmation des classes168
  - 1.2 Instanciation170
  - 1.3 Constructeur et destructeur172
  - 1.3.1 Constructeur172
  - 1.3.2 Le pointeur this173
  - 1.3.3 Destructeur174
  - 1.3.4 Destructeur virtuel175
  - 1.4 Allocation dynamique176
  - 1.5 Constructeur de copie178
  - 2. Héritage180
  - 2.1 Dérivation de classe (héritage)180
  - 2.1.1 Exemple de dérivation de classe180
  - 2.1.2 Héritage public, protégé et privé184
  - 2.1.3 Appel des constructeurs185
  - 2.2 Polymorphisme186
  - 2.2.1 Méthodes polymorphes187
  - 2.2.2 Conversions d'objets188
  - 2.3 Méthodes virtuelles et méthodes virtuelles pures188
  - 2.4 Héritage multiple193
  - 2.4.1 Notations particulières194
  - 2.4.2 Conséquences sur la programmation196
  - 3. Autres aspects de la POO198
  - 3.1 Conversion dynamique198
  - 3.1.1 Conversions depuis un autre type198
  - 3.1.2 Opérateurs de conversion200
  - 3.1.3 Conversions entre classes dérivées201
  - 3.2 Champs et méthodes statiques202
  - 3.2.1 Champs statiques202
  - 3.2.2 Méthodes statiques203
  - 3.3 Surcharge d'opérateurs208
  - 3.3.1 Syntaxe208
  - 3.3.2 Surcharge de l'opérateur d'indexation210
  - 3.3.3 Surcharge de l'opérateur d'affectation211
  - 3.3.4 Surcharge de l'opérateur de conversion211
  - 3.4 Fonctions amies212
  - 3.5 Adressage relatif et pointeurs de membres213
  - 3.5.1 Notations214
  - 3.5.2 Construction d'un middleware orienté objet215
  - 3.6 Programmation générique221
  - 3.6.1 Modèles de fonctions222
  - 3.6.2 Modèles de classes226
  - 4. Travaux pratiques231
  - 4.1 Utilisation de l'héritage de classes dans l'interprète tiny-lisp231
  - 4.2 Des pointeurs de membres pour des fonctions callback233
  - Chapitre 4
  - La bibliothèque Standard Template Library
  - 1. Introduction239
  - 2. Organisation des programmes240
  - 2.1 Espaces de noms240
  - 2.1.1 Utilisation complète d'un espace de noms242
  - 2.1.2 Espace de noms réparti sur plusieurs fichiers -243
  - 2.1.3 Relation entre classe et espace de noms244
  - 2.1.4 Déclaration de sous-espaces de noms246
  - 2.2 Présentation de la STL247
  - 3. Flux C+ + (entrées-sorties)247
  - 3.1 Généralités248
  - 3.2 Flux intégrés249
  - 3.3 État d'un flux249
  - 3.4 Mise en forme249
  - 3.5 Flux de fichiers251
  - 3.6 Flux de chaînes253
  - 3.7 Paramètres locaux254
  - 4. Classe string pour la représentation des chaînes de caractères256
  - 4.1 Représentation des chaînes dans la STL257
  - 4.2 Mode d'emploi de la classe string258
  - 4.2.1 Fonctions de base258
  - 4.2.2 Intégration dans le langage C++260
  - 4.2.3 Fonctions spécifiques aux chaînes262
  - 5. Conteneurs dynamiques264
  - 5.1 Conteneurs265
  - 5.1.1 Insertion d'éléments et parcours266
  - 5.1.2 Itérateurs266
  - 5.1.3 Opérations applicables à un vecteur267
  - 5.2 Séquences268
  - 5.2.1 Conteneurs standards268
  - 5.2.2 Séquences270
  - 5.2.3 Adaptateurs de séquences272
  - 5.2.4 Conteneurs associatifs276
  - 5.3 Algorithmes278
  - 5.3.1 Opérations de séquence sans modification278
  - 5.3.2 Opérations de séquence avec modification279
  - 5.3.3 Séquences triées280
  - 5.3.4 Algorithmes de définition281
  - 5.3.5 Minimum et maximum281
  - 5.4 Calcul numérique282
  - 5.4.1 Limites des formats ordinaires282
  - 5.4.2 Fonctions de la bibliothèque283
  - 5.4.3 Fonctions de la bibliothèque standard et classe valarray284
  - 5.5 Des apports du C ++ moderne285
  - 5.5.1 Les lambda-expressions285
  - 5.5.2 L'inférence de type287
  - 5.5.3 De nouveaux types de boucles289
  - 5.5.4 Des pointeurs intelligents290
  - 5.6 Introduction à la bibliothèque boost294
  - 5.6.1 Installation de la bibliothèque295
  - 5.6.2 Un premier exemple avec boost296
  - 5.6.3 Domaines d'application298
  - 6. Travaux pratiques299
  - 6.1 La classe Variant299
  - 6.2 La méthode to_string()301
  - 6.3 La traduction JSON302
  - 6.3.1 La méthode statique to_json_string()302
  - 6.3.2 La méthode statique from_json_string()304
  - Chapitre 5
  - Les univers de C++
  - 1. L'environnement Windows307
  - 1.1 Les programmes Win32307
  - 1.2 Choix du mode de compilation308
  - 1.3 Fonctionnement des applications fenêtrées Win32309
  - 1.3.1 Création d'un projet d'application fenêtrée310
  - 1.3.2 Les types de données Win32312
  - 1.3.3 Les handles et les messages314
  - 1.3.4 La boucle de message315
  - 1.3.5 Les fichiers de ressource316
  - 2. L'environnement .NET318
  - 2.1 Le code managé et la machine virtuelle CLR318
  - 2.2 Les adaptations du langage C++ CLI319
  - 2.2.1 La norme CTS319
  - 2.2.2 La classe System::String322
  - 2.2.3 Le garbage collector324
  - 2.2.4 Construction et destruction d'objets325
  - 2.2.5 La référence de suivi % et le handle ^329
  - 2.2.6 Le pointeur interne et les zones épinglées332
  - 2.2.7 Les tableaux et les fonctions à nombre variable d'arguments334
  - 2.2.8 Les propriétés336
  - 2.2.9 Les délégués et les événements338
  - 2.2.10 Les méthodes virtuelles340
  - 2.2.11 Les classes abstraites et les interfaces342
  - 2.3 Le framework .NET343
  - 2.3.1 Les références d'assemblages344
  - 2.3.2 L'espace de noms System::IO345
  - 2.3.3 L'espace de noms System::Xml346
  - 2.3.4 L'espace de noms System::Data347
  - 2.3.5 L'espace de noms System::Collections348
  - 2.3.6 L'espace de noms System::Collections::Generic349
  - 2.3.7 Le portage de la STL pour le C++ CLI350
  - 2.4 Les relations avec les autres langages : C#350
  - 3. Travaux pratiques352
  - 3.1 Réaliser une application de dessin Win32352
  - 3.2 Une application en C++ pour .NET : le tableur InCell360
  - 3.2.1 Architecture du tableur360
  - 3.2.2 La feuille de calcul362
  - 3.2.3 L'ordonnanceur de calcul370
  - 3.2.4 Zoom sur l'évaluateur374
  - 3.2.5 L'interface graphique375
  - 3.3 Un module de gestion de données pour tiny-lisp377
  - 3.3.1 Création de listes persistantes db_create378
  - 3.3.2 Accès aux listes persistantes db_use379
  - 3.3.3 Insertion d'items db_insert380
  - 3.3.4 Enregistrement des listes persistantes db_save381
  - 3.3.5 Sélection d'items dans les listes persistantes db_select383
  - Chapitre 6
  - Des programmes C++ efficaces
  - 1. Dépasser ses programmes385
  - 1.1 Oublier les réflexes du langage C385
  - 1.2 Gestion de la mémoire387
  - 1.3 Concevoir des classes avec soin388
  - 1.4 Y voir plus clair parmi les possibilités de l'héritage389
  - 1.5 Analyser l'exécution d'un programme C++390
  - 2. La conception orientée objet (COO)391
  - 2.1 Relation entre la POO et la COO391
  - 2.1.1 L'approche initiale de C++391
  - 2.1.2 UML et C++392
  - 2.2 Les design patterns395
  - 3. Travaux pratiques397
  - 3.1 L'objectif du programme397
  - 3.2 Le diagramme de classes397
  - 3.3 La fabrique SimpleFactory399
  - 3.4 L'injection de dépendances401
  - Chapitre 7
  - Des algorithmes appliqués en C++
  - 1. Introduction405
  - 2. Reconnaissance de motifs textuels405
  - 2.1 Approche directe406
  - 2.2 Lecture avec déplacement : l'algorithme Boyer Moore408
  - 2.3 Méthode pour les motifs auto répétitifs : l'algorithme KMP410
  - 2.4 Méthode pour des motifs variables412
  - 3. Recherche du plus court chemin414
  - 3.1 Présentation des graphes414
  - 3.1.1 Incidence et adjacence416
  - 3.1.2 Chemin d'un graphe416
  - 3.1.3 Implémentation des graphes orientés et non orientés417
  - 3.2 Le parcours de graphe en largeur d'abord420
  - 3.3 L'algorithme de Dijkstra423
  - 3.4 Utilisation d'une méthode avec heuristique : l'algorithme A*426
  - 3.4.1 Implémentation en C++427
  - 3.4.2 Exécution434
  - 4. Comprimer des fichiers437
  - 4.1 Approche par statistique : l'algorithme d'Huffman437
  - 4.1.1 Implémentation du codage438
  - 4.1.2 Compression du fichier442
  - 4.1.3 Décompression445
  - 4.2 Approche par dictionnaire : l'algorithme LZW445
  - 4.2.1 Fonctionnement de l'algorithme446
  - 4.2.2 Implémentation du dictionnaire447
  - 4.2.3 Dimensionnement et gestion du dictionnaire451
  - 4.2.4 Programme de compression452
  - 4.2.5 Programme de décompression454
  - Index457
Origine de la notice:
- Electre