Cours et exercices langage C++ pdf
Extrait du cours:
La compilation en C++
2.1 Le compilateur C++
2.1.1 Définition d’un compilateur
1. Qu’est ce qu’un compilateur ?
2. Identifier les principales phases de la compilation.
3. Citer des exemples de compilateurs.
2.1.2 La commande UNIX
1. Identifier la commande correspondant à l’appel du compilateur C (dans la suite, cette commande sera notée <cc>).
Quelle doit être l’extension des fichiers sources en langage C ?
2. Identifier la commande correspondant à l’appel du compilateur C++ (dans la suite, cette commande sera notée <cc++>).
Quelle doit être l’extension des fichiers sources en langage C++ ?
Cours et exercices langage C++ pdf
Table des matières :
Avant–propos 1
1 Rappels UNIX 3
1.1 Le système UNIX de travail . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 Organisation des TP . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Connexion/Déconnexion . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Organisation des répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Création de l’arborescence de travail . . . . . . . . . . . . . . . . . 4
1.2.2 La variable PATH . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Corrigés des TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Recherche d’un corrigé . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.2 Script de recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 La compilation en C++ 7
2.1 Le compilateur C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Définition d’un compilateur . . . . . . . . . . . . . . . . . . . . . . 7
2.1.2 La commande UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.3 Les principales options du compilateur C++ . . . . . . . . . . . . . 7
2.2 La chaˆıne de traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 L’édition du code source . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Le préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.3 La compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.4 L’édition de liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.5 L’exécution du programme . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Les erreurs de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.1 Erreurs liées au préprocesseur . . . . . . . . . . . . . . . . . . . . . 9
2.3.2 Erreurs liées au compilateur . . . . . . . . . . . . . . . . . . . . . . 9
2.3.3 Erreurs liées à l’éditeur de liens . . . . . . . . . . . . . . . . . . . . 9
3 Compilation conditionnelle, compilation séparée 11
3.1 La compilation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1 Manipulation de fonctions . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.2 Test d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 La compilation séparée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.1 Edition de liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.2 Utilisation d’une librairie . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Fichiers de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.1 Fichier fonction.h . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.2 Fichier fonction.C . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 La commande make 15
4.1 Le manuel UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.1 $ man make . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.2 “ The make command ” . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Evaluation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2.1 Un “ make ” explicite . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2.2 Un “ make ” implicite . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3 The make command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3.1 Command overview . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3.2 Synopsis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3.3 Description file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.3.4 Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3.5 Suffix Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.3.6 Flags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3.7 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5 Entrées/sorties en C++ 35
5.1 Les classes d’entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.1 Le graphe d’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.2 Injection dans un flot . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.3 Extraction d’un flot . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2 Copier un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.1 cin → cout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.2 source → destination . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3 iostream package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3.1 Synopsis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3.2 Core classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.3 Predefined streams . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.4 Classes derived from streambuf . . . . . . . . . . . . . . . . . . . . 39
5.3.5 Classes derived from istream, ostream, and iostream . . . . . . . 39
5.3.6 class ios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3.7 class ostream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.3.8 class istream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6 Un petit analyseur lexical 43
6.1 Lexèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.1.1 Représentation des lexèmes . . . . . . . . . . . . . . . . . . . . . . 44
6.1.2 Lecture d’un lexème . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.1.3 Ecriture d’un lexème . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2 Analyse lexicale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2.1 Analyseur lexical . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2.2 Evaluation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 44
7 Mes premières classes 45
7.1 Conventions d’écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.1.1 Interface d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.1.2 Implémentation d’une classe . . . . . . . . . . . . . . . . . . . . . . 46
7.1.3 Fonctions inline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7.2 Une classe Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7.2.1 Du TAD à l’interface de la classe . . . . . . . . . . . . . . . . . . . 46
7.2.2 L’implémentation de la classe . . . . . . . . . . . . . . . . . . . . . 47
7.2.3 L’utilisation de la classe . . . . . . . . . . . . . . . . . . . . . . . . 47
7.3 Les fichiers de la classe Exemple . . . . . . . . . . . . . . . . . . . . . . . . 47
7.3.1 Fichier exemple.h . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.3.2 Fichier exemple.Ci . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.3.3 Fichier exemple.C . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8 Mes premières piles 51
8.1 Du TAD au TCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.1 Le TAD Pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.2 Interface publique d’une PILE . . . . . . . . . . . . . . . . . . . . . 52
8.1.3 Choix d’une représentation physique . . . . . . . . . . . . . . . . . 52
8.1.4 Paramétrage de la classe PILE . . . . . . . . . . . . . . . . . . . . . 52
8.2 Implémentation en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.2.1 La classe PILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.2.2 Test de la classe PILE . . . . . . . . . . . . . . . . . . . . . . . . . . 53
9 Ma première calculette à pile 55
9.1 Le fichier Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9.1.1 Compilation de l’analyseur lexical . . . . . . . . . . . . . . . . . . . 56
9.1.2 Compilation de la RPile . . . . . . . . . . . . . . . . . . . . . . . . 56
9.1.3 Compilation de la calculette . . . . . . . . . . . . . . . . . . . . . . 56
9.1.4 Edition de liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2 Réalisation de la calculette . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2.1 Traitement des nombres . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2.2 Traitement des fonctions . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2.3 Traitement des opérateurs . . . . . . . . . . . . . . . . . . . . . . . 58
9.2.4 Autres traitements . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
10 Les opérateurs en C++ 59
10.1 Les chaˆınes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
10.2 Les nombres rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11 La généricité en C++ 61
11.1 Fonctions génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.1.1 Prototypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.1.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.1.3 Instanciations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.1.4 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.2 Classes génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.2.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.2.2 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.2.3 Instanciations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
12 Des piles et des tableaux 63
12.1 La classe SPile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.2 La classe DPile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.3 Interface de la classe SPile . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.3.1 Interface publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.3.2 Interface privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4 Interface de la classe DPile . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4.1 Interface privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4.2 Interface publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13 Des piles et des listes 67
13.1 La classe LPile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.2 Interface de la classe LPile . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.2.1 Interface publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.2.2 Interface privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
14 L’héritage en C++ 69
14.1 Modes d’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
14.2 Liaisons dynamiques et classes abstraites . . . . . . . . . . . . . . . . . . . 70
14.3 Les tours de Hanoï . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.4 Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14.4.1 La classe Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14.4.2 La classe D1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
14.4.3 La classe D2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.4.4 La classe D3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.4.5 Le fichier dyna.C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
14.4.6 La classe SPile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
15 Une famille de piles 79
16 Les difficultés du C++ 81
16.1 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
16.2 Destructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
16.3 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
16.4 Généricité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
16.5 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
16.6 Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
16.6.1 Fichier tableau.h . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
16.6.2 Classes A<T> et B . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
16.6.3 Classes C et D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
16.6.4 Classes E et F . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
17 Standard Template Library 89
17.1 Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
17.1.1 Définition et utilisation . . . . . . . . . . . . . . . . . . . . . . . . . 89
17.1.2 Classe IstreamIterator<T> . . . . . . . . . . . . . . . . . . . . . . 89
17.2 Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
17.2.1 vector<T>, deque<T> et list<T> . . . . . . . . . . . . . . . . . . . 89
17.2.2 Encore une pile ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
17.3 Tables associatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
17.3.1 Ensembles et tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
17.3.2 Dictionnaires et encyclopédies . . . . . . . . . . . . . . . . . . . . . 90
17.4 Anagrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
17.4.1 Trouver les anagrammes d’un mot . . . . . . . . . . . . . . . . . . . 91
17.4.2 Dictionnaire d’anagrammes . . . . . . . . . . . . . . . . . . . . . . 91
17.5 Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
17.5.1 La classe IstreamIterator<T> . . . . . . . . . . . . . . . . . . . . 92
18 La vie artificielle des “ bugs ” 93
18.1 Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
18.2 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
18.3 Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
18.3.1 La classe Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
18.3.2 La fonction main . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Cours et exercices langage C++ pdf
