C++ Des fondamentaux du langage aux applications (3e édition)

Présentation

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.

Table des matières

Avant-propos

1. Objectifs de ce livre
2. Travaux pratiques

Introduction

1. Notions clés
1. 1.1 Principales caractéristiques du langage C++
2. 1.2 Programmation orientée objet
3. 1.3 Environnement de développement et fichier makefile
  1. 1.3.1 Choix d'un EDI
  2. 1.3.2 Construction d'un fichier makefile
4. 1.4 Organisation d'un programme C++
  1. 1.4.1 Codes sources
  2. 1.4.2 Modules objets
  3. 1.4.3 Bibliothèques (librairies)
  4. 1.4.4 Exécutable
5. 1.5 Préprocesseur
6. 1.6 Choix d'un compilateur
7. 1.7 Éditeur de liens
2. Bases de la programmation C++
1. 2.1 Déclaration de variables
  1. 2.1.1 Utilité des variables
  2. 2.1.2 Portée des variables
  3. 2.1.3 Syntaxe de déclaration
  4. 2.1.4 Types de données
2. 2.2 Instructions de tests et opérateurs
  1. 2.2.1 Instructions de tests
  2. 2.2.2 Opérateurs
3. 2.3 Instructions de boucle
  1. 2.3.1 La boucle for
  2. 2.3.2 La boucle while
  3. 2.3.3 La boucle do
  4. 2.3.4 Les instructions de débranchement
4. 2.4 Tableaux
5. 2.5 Fonctions et prototypes
  1. 2.5.1 Déclaration d'une fonction
  2. 2.5.2 Fonctions et procédures
  3. 2.5.3 Appel des fonctions
  4. 2.5.4 Gestion des variables locales
  5. 2.5.5 Définition de fonctions homonymes (polymorphisme)
  6. 2.5.6 Fonctions à nombre variable d’arguments
  7. 2.5.7 Attribution de valeurs par défaut aux arguments
  8. 2.5.8 Fonctions en ligne
  9. 2.5.9 Fonctions externes de type C
  10. 2.5.10 Fonctions récursives
  11. 2.5.11 La fonction main()
6. 2.6 Pointeurs
  1. 2.6.1 Pointeurs sur des variables
  2. 2.6.2 Pointeurs et tableaux
  3. 2.6.3 Allocation de mémoire
  4. 2.6.4 Arithmétique des pointeurs
  5. 2.6.5 Pointeurs de pointeurs
  6. 2.6.6 Pointeurs de fonctions
7. 2.7 Références
8. 2.8 Constantes
  1. 2.8.1 Constantes symboliques
  2. 2.8.2 Le type void
  3. 2.8.3 Les alias de type : typedef
  4. 2.8.4 Constantes et énumérations
3. Exceptions
1. 3.1 Les approches de bas niveau
  1. 3.1.1 Drapeaux et interruptions
  2. 3.1.2 Traitement des erreurs en langage C
2. 3.2 Les exceptions plus sûres que les erreurs
3. 3.3 Propagation explicite
4. 3.4 Types d'exceptions personnalisés
  1. 3.4.1 Définition de classes d'exception
  2. 3.4.2 Instanciation de classes
  3. 3.4.3 Classes d'exception dérivées
5. 3.5 Prise en charge d'une exception et relance
6. 3.6 Exceptions non interceptées
7. 3.7 Acquisition de ressources
4. Travaux pratiques
1. 4.1 Prise en main de l'interprète tiny-lisp
  1. 4.1.1 Structure de la solution
  2. 4.1.2 Le dossier config
  3. 4.1.3 Le dossier framework
  4. 4.1.4 Le dossier jsonlib
  5. 4.1.5 Le dossier langage
  6. 4.1.6 Le dossier modules
  7. 4.1.7 Le dossier scriptboxes
2. 4.2 Utiliser l'interprète en mode interactif
3. 4.3 Code de la boucle principale
  1. 4.3.1 La fonction main()
  2. 4.3.2 La boucle eval_loop()
  3. 4.3.3 Utiliser le débogueur
4. 4.4 Utiliser l'interprète depuis tinylisplab

De C à C++

1. Programmation structurée
1. 1.1 Structures
  1. 1.1.1 Constitution d'une structure
  2. 1.1.2 Instanciation de structures
  3. 1.1.3 Instanciation avec l'opérateur new
  4. 1.1.4 Pointeurs et structures
  5. 1.1.5 Organisation de la programmation
2. 1.2 Unions
3. 1.3 Copie de structures
4. 1.4 Création d'alias de types de structures
5. 1.5 Structures et fonctions
  1. 1.5.1 Passer une structure par valeur comme paramètre
  2. 1.5.2 Passer une structure par référence comme paramètre
  3. 1.5.3 Passer une structure par adresse comme paramètre
  4. 1.5.4 De la programmation fonctionnelle à la programmation objet
2. Gestion de la mémoire
1. 2.1 Alignement des données
2. 2.2 Allocation de mémoire interprocessus
3. La bibliothèque standard du C
1. 3.1 Les fonctions communes du langage C <stdlib.h>
2. 3.2 Chaînes <string.h>
3. 3.3 Fichiers <stdio.h>
4. Travaux pratiques
1. 4.1 Chargement de scripts dans tiny-lisp
2. 4.2 Supprimer les erreurs liées à la librairie non sécurisée

Programmation orientée objet

1. Classes et instances
1. 1.1 Définition de classe
  1. 1.1.1 Les modificateurs d'accès
  2. 1.1.2 Organisation de la programmation des classes
2. 1.2 Instanciation
3. 1.3 Constructeur et destructeur
  1. 1.3.1 Constructeur
  2. 1.3.2 Le pointeur this
  3. 1.3.3 Destructeur
  4. 1.3.4 Destructeur virtuel
4. 1.4 Allocation dynamique
5. 1.5 Constructeur de copie
2. Héritage
1. 2.1 Dérivation de classe (héritage)
  1. 2.1.1 Exemple de dérivation de classe
  2. 2.1.2 Héritage public, protégé et privé
  3. 2.1.3 Appel des constructeurs
2. 2.2 Polymorphisme
  1. 2.2.1 Méthodes polymorphes
  2. 2.2.2 Conversions d'objets
3. 2.3 Méthodes virtuelles et méthodes virtuelles pures
4. 2.4 Héritage multiple
  1. 2.4.1 Notations particulières
  2. 2.4.2 Conséquences sur la programmation
3. Autres aspects de la POO
1. 3.1 Conversion dynamique
  1. 3.1.1 Conversions depuis un autre type
  2. 3.1.2 Opérateurs de conversion
  3. 3.1.3 Conversions entre classes dérivées
2. 3.2 Champs et méthodes statiques
  1. 3.2.1 Champs statiques
  2. 3.2.2 Méthodes statiques
3. 3.3 Surcharge d'opérateurs
  1. 3.3.1 Syntaxe
  2. 3.3.2 Surcharge de l'opérateur d'indexation
  3. 3.3.3 Surcharge de l'opérateur d'affectation
  4. 3.3.4 Surcharge de l'opérateur de conversion
4. 3.4 Fonctions amies
5. 3.5 Adressage relatif et pointeurs de membres
  1. 3.5.1 Notations
  2. 3.5.2 Construction d'un middleware orienté objet
6. 3.6 Programmation générique
  1. 3.6.1 Modèles de fonctions
  2. 3.6.2 Modèles de classes
4. Travaux pratiques
1. 4.1 Utilisation de l'héritage de classes dans l'interprète tiny-lisp
2. 4.2 Des pointeurs de membres pour des fonctions callback

La bibliothèque Standard Template Library

1. Introduction
2. Organisation des programmes
1. 2.1 Espaces de noms
  1. 2.1.1 Utilisation complète d'un espace de noms
  2. 2.1.2 Espace de noms réparti sur plusieurs fichiers
  3. 2.1.3 Relation entre classe et espace de noms
  4. 2.1.4 Déclaration de sous-espaces de noms
2. 2.2 Présentation de la STL
3. Flux C++ (entrées-sorties)
1. 3.1 Généralités
2. 3.2 Flux intégrés
3. 3.3 État d'un flux
4. 3.4 Mise en forme
5. 3.5 Flux de fichiers
6. 3.6 Flux de chaînes
7. 3.7 Paramètres locaux
4. Classe string pour la représentation des chaînes de caractères
1. 4.1 Représentation des chaînes dans la STL
2. 4.2 Mode d'emploi de la classe string
  1. 4.2.1 Fonctions de base
  2. 4.2.2 Intégration dans le langage C++
  3. 4.2.3 Fonctions spécifiques aux chaînes
5. Conteneurs dynamiques
1. 5.1 Conteneurs
  1. 5.1.1 Insertion d'éléments et parcours
  2. 5.1.2 Itérateurs
  3. 5.1.3 Opérations applicables à un vecteur
2. 5.2 Séquences
  1. 5.2.1 Conteneurs standards
  2. 5.2.2 Séquences
  3. 5.2.3 Adaptateurs de séquences
  4. 5.2.4 Conteneurs associatifs
3. 5.3 Algorithmes
  1. 5.3.1 Opérations de séquence sans modification
  2. 5.3.2 Opérations de séquence avec modification
  3. 5.3.3 Séquences triées
  4. 5.3.4 Algorithmes de définition
  5. 5.3.5 Minimum et maximum
4. 5.4 Calcul numérique
  1. 5.4.1 Limites des formats ordinaires
  2. 5.4.2 Fonctions de la bibliothèque
  3. 5.4.3 Fonctions de la bibliothèque standard et classe valarray
5. 5.5 Des apports du C++ moderne
  1. 5.5.1 Les lambda-expressions
  2. 5.5.2 L'inférence de type
  3. 5.5.3 De nouveaux types de boucles
  4. 5.5.4 Des pointeurs intelligents
6. 5.6 Introduction à la bibliothèque boost
  1. 5.6.1 Installation de la bibliothèque
  2. 5.6.2 Un premier exemple avec boost
  3. 5.6.3 Domaines d'application
6. Travaux pratiques
1. 6.1 La classe Variant
2. 6.2 La méthode to_string()
3. 6.3 La traduction JSON
  1. 6.3.1 La méthode statique to_json_string()
  2. 6.3.2 La méthode statique from_json_string()

Les univers de C++

1. L'environnement Windows
1. 1.1 Les programmes Win32
2. 1.2 Choix du mode de compilation
3. 1.3 Fonctionnement des applications fenêtrées Win32
  1. 1.3.1 Création d'un projet d'application fenêtrée
  2. 1.3.2 Les types de données Win32
  3. 1.3.3 Les handles et les messages
  4. 1.3.4 La boucle de message
  5. 1.3.5 Les fichiers de ressource
2. L'environnement .NET
1. 2.1 Le code managé et la machine virtuelle CLR
2. 2.2 Les adaptations du langage C++ CLI
  1. 2.2.1 La norme CTS
  2. 2.2.2 La classe System::String
  3. 2.2.3 Le garbage collector
  4. 2.2.4 Construction et destruction d'objets
  5. 2.2.5 La référence de suivi % et le handle ^
  6. 2.2.6 Le pointeur interne et les zones épinglées
  7. 2.2.7 Les tableaux et les fonctions à nombre variable d'arguments
  8. 2.2.8 Les propriétés
  9. 2.2.9 Les délégués et les événements
  10. 2.2.10 Les méthodes virtuelles
  11. 2.2.11 Les classes abstraites et les interfaces
3. 2.3 Le framework .NET
  1. 2.3.1 Les références d'assemblages
  2. 2.3.2 L'espace de noms System::IO
  3. 2.3.3 L'espace de noms System::Xml
  4. 2.3.4 L'espace de noms System::Data
  5. 2.3.5 L'espace de noms System::Collections
  6. 2.3.6 L'espace de noms System::Collections::Generic
  7. 2.3.7 Le portage de la STL pour le C++ CLI
4. 2.4 Les relations avec les autres langages : C#
3. Travaux pratiques
1. 3.1 Réaliser une application de dessin Win32
2. 3.2 Une application en C++ pour .NET : le tableur InCell
  1. 3.2.1 Architecture du tableur
  2. 3.2.2 La feuille de calcul
  3. 3.2.3 L'ordonnanceur de calcul
  4. 3.2.4 Zoom sur l'évaluateur
  5. 3.2.5 L'interface graphique
3. 3.3 Un module de gestion de données pour tiny-lisp
  1. 3.3.1 Création de listes persistantes db_create
  2. 3.3.2 Accès aux listes persistantes db_use
  3. 3.3.3 Insertion d'items db_insert
  4. 3.3.4 Enregistrement des listes persistantes db_save
  5. 3.3.5 Sélection d'items dans les listes persistantes db_select

Des programmes C++ efficaces

1. Dépasser ses programmes
1. 1.1 Oublier les réflexes du langage C
2. 1.2 Gestion de la mémoire
3. 1.3 Concevoir des classes avec soin
4. 1.4 Y voir plus clair parmi les possibilités de l’héritage
5. 1.5 Analyser l’exécution d’un programme C++
2. La conception orientée objet (COO)
1. 2.1 Relation entre la POO et la COO
  1. 2.1.1 L'approche initiale de C++
  2. 2.1.2 UML et C++
2. 2.2 Les design patterns
3. Travaux pratiques
1. 3.1 L'objectif du programme
2. 3.2 Le diagramme de classes
3. 3.3 La fabrique SimpleFactory
4. 3.4 L'injection de dépendances

Des algorithmes appliqués en C++

1. Introduction
2. Reconnaissance de motifs textuels
1. 2.1 Approche directe
2. 2.2 Lecture avec déplacement : l'algorithme Boyer Moore
3. 2.3 Méthode pour les motifs auto répétitifs : l'algorithme KMP
4. 2.4 Méthode pour des motifs variables
3. Recherche du plus court chemin
1. 3.1 Présentation des graphes
  1. 3.1.1 Incidence et adjacence
  2. 3.1.2 Chemin d'un graphe
  3. 3.1.3 Implémentation des graphes orientés et non orientés
2. 3.2 Le parcours de graphe en largeur d'abord
3. 3.3 L'algorithme de Dijkstra
4. 3.4 Utilisation d'une méthode avec heuristique : l'algorithme A*
  1. 3.4.1 Implémentation en C++
  2. 3.4.2 Exécution
4. Comprimer des fichiers
1. 4.1 Approche par statistique : l'algorithme d'Huffman
  1. 4.1.1 Implémentation du codage
  2. 4.1.2 Compression du fichier
  3. 4.1.3 Décompression
2. 4.2 Approche par dictionnaire : l'algorithme LZW
  1. 4.2.1 Fonctionnement de l'algorithme
  2. 4.2.2 Implémentation du dictionnaire
  3. 4.2.3 Dimensionnement et gestion du dictionnaire
  4. 4.2.4 Programme de compression
  5. 4.2.5 Programme de décompression
  8. Index

Auteur

Brice-Arnaud GUÉRINEn savoir plus

Ingénieur ESIEA, Brice-Arnaud GUERIN est Directeur de programmes chez Kantar et auteur aux Editions ENI depuis 2003. Ses compétences en développement et son désir de partager ses connaissances l'ont naturellement conduit à l'écriture d'ouvrages consacrés à la conduite de projets et à la réalisation d'applications (C++, .NET, PHP).