Ce support 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 explique les notions clés pour créer ses premières applications : gestion de la mémoire, pointeurs, bibliothèques standards… Le troisième chapitre détaille la structuration des données, conduisant à la programmation orientée objet et aux 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 é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’applica­tions, l’auteur propose un exemple complet de tableur graphique, un interprète du langage tiny-Lisp, un programme de compression de fichiers ou encore un réseau de neurones appliqué à un démonstrateur de calculs.

L’ouvrage se termine par un chapitre appliquant des algorithmes essen­tiels 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.

Téléchargements

• Des fichiers complémentaires (7 569 Ko)

Avant-propos

1. 1. Objectifs de ce livre
2. 2. Travaux pratiques

Premiers pas en C++

1. 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. 2. Les premiers programmes
   1. 2.1 Les commentaires
   2. 2.2 Déclaration de variables
      1. 2.2.1 Utilité des variables
      2. 2.2.2 Portée des variables
      3. 2.2.3 Syntaxe de déclaration
      4. 2.2.4 Types de données
      5. 2.2.5 Les types entiers
      6. 2.2.6 Les types décimaux
      7. 2.2.7 Le booléen
      8. 2.2.8 Les caractères et les chaînes
   3. 2.3 Instructions de tests et opérateurs
      1. 2.3.1 Instructions de tests
      2. 2.3.2 Opérateurs
      3. 2.3.3 Opérateurs booléens
      4. 2.3.4 Opérateurs d'incrémentation
      5. 2.3.5 Instructions de boucle
      6. 2.3.6 La boucle while
      7. 2.3.7 La boucle for
      8. 2.3.8 La boucle do
      9. 2.3.9 Les instructions de débranchement
3. 3. Tableaux
   1. 3.1 Déclarer des tableaux
   2. 3.2 Tableaux dynamiques
4. 4. Fonctions et prototypes
   1. 4.1 Déclaration d'une fonction
   2. 4.2 Fonctions et procédures
   3. 4.3 Appel des fonctions
   4. 4.4 Gestion des variables locales
   5. 4.5 Définition de fonctions homonymes (polymorphisme)
   6. 4.6 Fonctions à nombre variable d’arguments
   7. 4.7 Attribution de valeurs par défaut aux arguments
   8. 4.8 Fonctions en ligne
   9. 4.9 Fonctions externes de type C
   10. 4.10 Fonctions récursives
   11. 4.11 La fonction main()

De la mémoire pour les programmes

1. 1. Pointeurs
   1. 1.1 Pointeurs sur des variables
   2. 1.2 Pointeurs et tableaux
   3. 1.3 Allocation de mémoire
      1. 1.3.1 Allocation par malloc()
      2. 1.3.2 Allocation par new
   4. 1.4 Arithmétique des pointeurs
   5. 1.5 Pointeurs de pointeurs
   6. 1.6 Pointeurs de fonctions
      1. 1.6.1 Utilisation pour rendre les algorithmes génériques
      2. 1.6.2 Fonctions callback
2. 2. Références
   1. 2.1 Une plus grande sécurité
   2. 2.2 Les références constantes
   3. 2.3 Renvoyer une référence depuis une fonction
3. 3. Constantes
   1. 3.1 Constantes symboliques
   2. 3.2 Le type void
   3. 3.3 Les alias de type : typedef
   4. 3.4 Constantes et énumérations
4. 4. Exercices pratiques
   1. 4.1 Rechercher la valeur maximale dans un tableau
      1. 4.1.1 Déclaration du tableau
      2. 4.1.2 Implémentation de l'algorithme sous forme d'une fonction
      3. 4.1.3 Exécution de l'algorithme
   2. 4.2 Rechercher l'adresse de la valeur maximale dans un tableau
   3. 4.3 Utiliser les références pour rechercher l'index de la valeur maximale dans un tableau

Structuration des données

1. 1. Programmation structurée
   1. 1.1 Structures
   2. 1.2 Constitution d'une structure
   3. 1.3 Instanciation de structures
   4. 1.4 Instanciation au moment de la définition
   5. 1.5 Instanciation par réservation de mémoire
   6. 1.6 Instanciation avec l'opérateur new
   7. 1.7 Pointeurs et structures
   8. 1.8 Organisation de la programmation
      1. 1.8.1 Inclusion à l'aide de #include
      2. 1.8.2 Protection contre les inclusions multiples
   9. 1.9 Unions
   10. 1.10 Copie de structures
   11. 1.11 Création d'alias de types de structures
2. 2. Structures et fonctions
   1. 2.1 Passer comme paramètre une structure par valeur
   2. 2.2 Passer comme paramètre une structure par référence
   3. 2.3 Passer comme paramètre une structure par adresse
   4. 2.4 De la programmation fonctionnelle à la programmation objet
   5. 2.5 Gestion de la mémoire
      1. 2.5.1 Alignement des données
      2. 2.5.2 Allocation de mémoire interprocessus
3. 3. La bibliothèque standard du C
   1. 3.1 Les fonctions communes du langage C
   2. 3.2 Chaînes
   3. 3.3 Fichiers
4. 4. Exercices pratiques
   1. 4.1 Les structures
   2. 4.2 La fonction d'initialisation
   3. 4.3 Les fonctions d'affichage
   4. 4.4 Les fonctions d'entrées et de sorties
   5. 4.5 La fonction principale
   6. 4.6 Exécution du programme et tests

La programmation orientée objet

1. 1. Classes et instances
   1. 1.1 Définition de classe
   2. 1.2 Les modificateurs d'accès
   3. 1.3 Organisation de la programmation des classes
   4. 1.4 Instanciation
   5. 1.5 Constructeur
   6. 1.6 Le pointeur this
   7. 1.7 Destructeur
   8. 1.8 Destructeur virtuel
   9. 1.9 Allocation dynamique
   10. 1.10 Constructeur de copie
2. 2. Héritage
   1. 2.1 Dérivation de classe (héritage)
   2. 2.2 Exemple de dérivation de classe
   3. 2.3 Héritage public, protégé et privé
   4. 2.4 Appel des constructeurs
   5. 2.5 Polymorphisme
   6. 2.6 Méthodes polymorphes
   7. 2.7 Conversions d'objets
   8. 2.8 Méthodes virtuelles et méthodes virtuelles pures
   9. 2.9 Héritage multiple
   10. 2.10 Notations particulières pour l'héritage multiple
   11. 2.11 Conséquences de l'héritage multiple sur la programmation
3. 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
4. 4. Les exceptions plus sûres que les erreurs
   1. 4.1 Propagation explicite
   2. 4.2 Types d'exceptions personnalisés
      1. 4.2.1 Définition de classes d'exception
      2. 4.2.2 Instanciation de classes
      3. 4.2.3 Classes d'exception dérivées
   3. 4.3 Prise en charge d'une exception et relance
   4. 4.4 Exceptions non interceptées
   5. 4.5 Acquisition de ressources
5. 5. Programmation générique
   1. 5.1 Modèles de fonctions
   2. 5.2 Modèles de classes
6. 6. Travaux pratiques
   1. 6.1 Utilisation de l'héritage de classes dans l'interprète tiny-lisp
   2. 6.2 Des pointeurs de membres pour des fonctions callback

La librairie standard STL

1. 1. Introduction
2. 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 librairie STL
3. 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. 4. Classe string pour la représentation des chaînes de caractères
   1. 4.1 Représentation des chaînes dans la librairie STL
   2. 4.2 Mode d'emploi de la classe string
      1. 4.2.1 Fonctions de base
      2. 4.2.2 Constructeurs
      3. 4.2.3 Itérateurs
      4. 4.2.4 Accès aux éléments
   3. 4.3 Intégration dans le langage C++
      1. 4.3.1 Affectations
      2. 4.3.2 Comparaisons
      3. 4.3.3 Conversion avec le C
   4. 4.4 Fonctions spécifiques aux chaînes
      1. 4.4.1 Insertion
      2. 4.4.2 Concaténation
      3. 4.4.3 Recherche et remplacement
      4. 4.4.4 Extraction de sous-chaîne
5. 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 Conteneurs standard
      1. 5.2.1 Itérateurs
      2. 5.2.2 Accès aux éléments
      3. 5.2.3 Opérations sur pile et file
      4. 5.2.4 Opérations sur listes
      5. 5.2.5 Opérations associatives
   3. 5.3 La séquence list
   4. 5.4 La séquence deque
   5. 5.5 Adaptateurs de séquences
   6. 5.6 La pile stack
   7. 5.7 La file queue
   8. 5.8 La file d'attente à priorité
   9. 5.9 Le conteneur associatif map
   10. 5.10 Les conteneurs associatifs multimap, set et multiset
6. 6. Algorithmes
   1. 6.1 Opérations de séquence sans modification
   2. 6.2 Opérations de séquence avec modification
   3. 6.3 Séquences triées
   4. 6.4 Algorithmes ensemblistes
   5. 6.5 Minimum et maximum
   6. 6.6 Calcul numérique
      1. 6.6.1 Limites des formats ordinaires
      2. 6.6.2 Fonctions de la bibliothèque
      3. 6.6.3 Fonctions de la bibliothèque standard et classe valarray
7. 7. Des apports du C++ moderne
   1. 7.1 Les lambda-expressions
   2. 7.2 L'inférence de type
   3. 7.3 De nouveaux types de boucles
   4. 7.4 Des pointeurs intelligents
8. 8. Introduction à la bibliothèque boost
   1. 8.1 Installation de la bibliothèque
   2. 8.2 Un premier exemple avec boost
   3. 8.3 Domaines d'application
9. 9. Travaux pratiques
   1. 9.1 La classe Variant
   2. 9.2 La méthode to_string()
   3. 9.3 La traduction JSON
      1. 9.3.1 La méthode statique to_json_string()
      2. 9.3.2 La méthode statique from_json_string()

Les environnements de C++

1. 1. L'environnement Windows
   1. 1.1 Les programmes Win32
      1. 1.1.1 Choix du mode de compilation
      2. 1.1.2 Fonctionnement des applications fenêtrées Win32
      3. 1.1.3 Création d'un projet d'application fenêtrée
      4. 1.1.4 Les types de données Win32
      5. 1.1.5 Les handles et les messages
      6. 1.1.6 La boucle de message
      7. 1.1.7 Les fichiers de ressource
   2. 1.2 L'environnement .NET
      1. 1.2.1 Le code managé et la machine virtuelle CLR
      2. 1.2.2 Les adaptations du langage C++ CLI
      3. 1.2.3 La norme CTS
      4. 1.2.4 La classe System::String
      5. 1.2.5 Le garbage collector
      6. 1.2.6 Fonctionnement du ramasse-miettes
      7. 1.2.7 Les tableaux et les fonctions à nombre variable d'arguments
      8. 1.2.8 Les propriétés
      9. 1.2.9 Les délégués et les événements
      10. 1.2.10 Les méthodes virtuelles
      11. 1.2.11 Les classes abstraites et les interfaces
      12. 1.2.12 Le framework .NET
      13. 1.2.13 Les références d'assemblages
      14. 1.2.14 L'espace de noms System::IO
      15. 1.2.15 L'espace de noms System::Xml
      16. 1.2.16 L'espace de noms System::Data
      17. 1.2.17 L'espace de noms System::Collections
      18. 1.2.18 L'espace de noms System::Collections::Generic
   3. 1.3 Les relations avec les autres langages : exemple du C#
2. 2. Applications
   1. 2.1 Réaliser une application de dessin Win32
   2. 2.2 Une application en C++ pour .NET : le tableur InCell
      1. 2.2.1 Architecture du tableur
      2. 2.2.2 La feuille de calcul
      3. 2.2.3 L'ordonnanceur de calcul
      4. 2.2.4 Zoom sur l'évaluateur
      5. 2.2.5 L'interface graphique
   3. 2.3 Un module de gestion de données pour tiny-lisp
      1. 2.3.1 Création de listes persistantes db_create
      2. 2.3.2 Accès aux listes persistantes db_use
      3. 2.3.3 Insertion d'items db_insert
      4. 2.3.4 Enregistrement des listes persistantes db_save
      5. 2.3.5 Sélection d'items dans les listes persistantes db_select

Programmer des algorithmes en C++

1. 1. Introduction
2. 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
3. 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 Le parcours de graphe en largeur d'abord
   2. 3.2 L'algorithme de Dijkstra
   3. 3.3 Utilisation d'une méthode avec heuristique : l'algorithme A*
4. 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
5. 5. Implémenter un réseau de neurones en C++
   1. 5.1 Un réseau de neurones pour l'algorithmique ?
   2. 5.2 Implémentation d'un réseau de neurones en C++
   3. 5.3 Une classe abstraite pour piloter le réseau
   4. 5.4 Modéliser une porte logique
   5. 5.5 Un moteur d'inférence pour l'arithmétique entière
      1. 5.5.1 Apprentissage des symboles
      2. 5.5.2 Utilisation du réseau
      3.  
6.  
7.  
8. Index