INTRODUCTION À LA CONCEPTION OBJET ET À C++

Introduction au langage C++

Historique

Le langage C++ est un langage complexe que ce seul polycopié ne peut pas exhaustivement couvrir. Le lecteur pourra se reporter à des ouvrages tels que [ Str 97] et [Lip 98] (ou sa traduction française [ Lip 92]) pour de plus amples informations. Un excellent ouvrage est aussi disponible gratuitement sur le Web à l’adresse http://www.EckelObjects.com/ThinkingInCPP2e.html. C++ peut être considéré comme une extension de C, si bien que tout programme C valide est un programme C++ valide. La différence par rapport à C est essentiellement faite au niveau des fonctionnalités objets ajoutées, et de quelques conventions différentes étudiées dans ce polycopié.
Tout comme le langage C, le langage C++ a été conçu dans les laboratoires AT&T Bell. Son concepteur, Bjarne Stroustrup, désirait étendre les fonctionnalités du langage C afin d’y intégrer les concepts de la programmation par objet. Il désirait en effet conserver les habitudes des programmeurs C, leur permettre de récupérer une bonne partie des programmes qu’ils avaient développés, tout en intégrant les avantages de la programmation objet, en s’inspirant de langages tels que simula. Ceci a donné naissance en 1979 au langage C+, qui intégrait quelques fonctionnalités objet, et en 1983 au langage C++, un peu plus complet, incluant notamment la généricité, la liaison dynamique… Le langage a continué ensuite à évoluer, jusqu’à l’adoption d’une norme qui est assez récente, puisqu’elle date de la fin de 1997. Ce polycopié ne s’attarde pas sur les dernières fonctionnalités offertes par la norme définitive du langage, que peu de compilateurs supportent dans leur globalité, mais plutôt sur les bases mêmes offertes par ce langage. De même, les fonctionnalités communes aux langages C et C++ ne sont pas reprises ; seules les différences sont soulignées. Le lecteur doit donc avoir une bonne connaissance du langage C pour aborder cette introduction.

Implantation de modules en C++

Tout comme en C, un module C++ est généralement implanté par deux fichiers : un fichier d’interface qui regroupe les services offerts par le module (définition de types, constantes, déclaration de fonctions) et un fichier d’implantation qui permet de définir les fonctions déclarées dans l’interface. Les extensions conventionnellement utilisées en C++ sont :
– .hh, .H pour les fichiers d’interface C++ (les headers). Il n’est pas rare cependant de voir des fichiers d’extension .h contenir des interfaces C++.
Remarque : la norme finale du langage C++ prévoit que les fichiers d’interface perdent leur extension.
C’est la raison pour laquelle les interfaces spécifiques au C++ sont désormais désignées sans leur extension (comme iostream par exemple). Il en est de même pour lesheaders déjà disponibles en C. Ceux-ci sont de plus préfixés par le caractère «c ». Ainsi, stdio.h est maintenant dénominé par cstdio.
– .cc, .cpp, .C pour les fichiers d’implantation C++. Ici par contre les extensions sont bien différenciées et sont souvent utilisées directement par les compilateurs pour déterminer le type de compilation (C, C++) à effectuer.

Types de base

Les types de bases disponibles en C, tels que char, int, float, double, void sont égale-ment disponibles en C++. Un type supplémentaire a été introduit pour manipuler de manière plus rigou-reuse et plus explicite les booléens, c’est le typebool [PROG. 2.1]. Les variables de type bool peuvent avoir deux valeurs différentes :true ou false. Cependant, afin de rester compatible avec les variables booléennes utilisées en C, il est toujours possible de stocker et de manipuler des booléens à partir de variables de type int.
1 bool stop = false;
2
3 while (!stop) {
4 …
5 }
PROG. 2.1 – Exemple d’utilisation d’un booléen.

Commentaires

Il existe deux moyens de définir des commentaires en C++. Le premier moyen correspond à des com-mentaires longs et est déjà disponible sous C. Il correspond aux délimiteurs «/* */ » : tout ce qui se trouve entre ces deux délimiteurs est considéré comme commentaire, même s’il y a des changements de lignes. Le deuxième moyen permet de définir des commentaires courts, tenant sur une seule ligne. Il corres-pond au délimiteur «// » : tout ce qui se trouve à droite de ce délimiteur sur la mêmeligne est considéré comme commentaire [PROG. 2.2].
1 /*
2 Ceci est un commentaire de
3 plusieurs lignes
4 */
5
6 bool stop; // Commentaire court
PROG. 2.2 – Deux types de commentaires disponibles.

Structure d’un programme C++

La structure minimale d’un programme C++ est similaire à celle d’un programme C. Elle peut ensuite être étendue par des éléments (fonctions, instructions, structures de contrôle, etc…) abordés lors de l’étude du langage C, et par les éléments propres au C++ présentés dans ce polycopié. La fonction principale, appelée lors du début de l’exécution d’un programme, est la fonction main qui peut être définie de deux manières différentes [PROG. 2.3].
1 int main() { … } // Programme sans paramètre
2
3 /* Programme avec paramètres :
4 argc : nombre de paramètres (y compris le nom du programme)
5 argv : tableau de paramètres, argc entrées
6 */
7
8 int main(int argc, char *argv[]) { … }
PROG. 2.3 – Structure minimale d’un programme C++.

Les fonctions

Les fonctions C++ se déclarent et se définissent comme en C. Plusieurs caractéristiques ont cependant été ajoutées ou modifiées.
– Vérification stricte des types. Contrairement à C qui est un langage faiblement typé, et qui autorise ainsi l’utilisation d’une fonction avant sa définition ou sa déclaration1, C++ est un langage fortement typé. L’utilisation d’une fonction sans une déclaration ou une définition préalable conduit à une erreur de compilation.
– Possibilité de définir des valeurs par défaut pour certains paramètres de fonctions Certaines. fonctions sont appelées avec des paramètres qui changent rarement. Considérons par exemple une fonction EcranInit qui est chargée d’initialiser un écran d’ordinateur (en mode caractères). Dans 90 % des cas, l’écran a les dimensions 24 lignes× 80 caractères et doit être initialisé dans 99 % des cas avec le caractère ’ ’, qui provoque l’effacement de l’écran. Plutôt que de contraindre le programmeur à énumérer des paramètres qui sont généralement invariants, C++ offre la possibilité de donner des valeurs par défaut à certains paramètres lors de la déclaration de la fonction [PROG. 2.4]. Quelques remarques sur cette fonctionnalité :
1. Une fonction peut définir des valeurs par défaut pour tous ses paramètres ou seulement pour une partie. Les paramètres acceptant des valeurs par défaut doivent se trouveraprès les paramètres sans valeur par défaut dans la liste des paramètres acceptés par une fonction.
2. Les valeurs par défaut de chaque paramètre ne peuvent être mentionnées qu’une seule fois parmi les définitions / déclarations d’une fonction. Ainsi, par convention, ces valeurs sont généralement mentionnées dans la déclaration de la fonction et pas dans sa définition (donc dans le .H et pas dans le .C).
3. L’ordre de déclaration des paramètres est important : dans l’exemple [PROG. 2.4] il est en effet impossible de donner une valeur à col sans en donner une auparavant à lig. D’une façon générale, il faut donc positionner parmi les paramètres ayant des valeurs par défaut en premier ceux qui ont le plus de chances d’être modifiés.
1. La fonction en question est alors supposée par défaut renvoyer un entier (typeint).
1 void EcranInit(Ecran ecran, int lig = 24, int col = 80, char fond = ’ ’);
2
3 void EcranInit(Ecran ecran, int lig, int col, char fond)
4 {
5 …
6 }
7
8 int main()
9 {
10 Ecran ec;
11
12 EcranInit(ec); // Éq. à : EcranInit(ecran, 24, 80, ’ ’);
13 EcranInit(ec, 26);// Éq. à : EcranInit(ecran, 26, 80, ’ ’);
14 EcranInit(ec, 26, 92);// Éq. à : EcranInit(ecran, 26, 92, ’ ’);
15 EcranInit(ec, 26, 92, ’+’);
16 }
PROG. 2.4 – Exemple d’initialisations par défaut.
– Définition de fonctions inline. Les fonctions offrent beaucoup d’avantages, mais ont un inconvé-nient majeur lorsque le nombre d’instructions qu’elles comportent est réduit : elles sont coûteuses en temps d’exécution (exemple : fonctionint min(int a, int b);). En effet, à chaque appel de fonction, le système met à jour un certain nombre de valeurs (essentiellement avec la pile) et effectue d’autres mises à jour lors de la terminaison de la fonction. Le coût de ces mises à jour est d’autant plus élevé (relativement) que le nombre d’instructions contenues dans la fonction est réduit, ce qui peut être critique dans des traitements exigeant de hautes performances. On peut cependant vouloir garder la structure offerte par les fonctions pour des raisons de lisibilité, d’uniformisation, de réutilisation. La solution est de définir ce genre de fonctions commeinline [PROG. 2.5].
1 // Définition dans une interface (.H)
2
3 inline int min(int a, int b)
4 {
5 return ((a < b)? a : b);
6 }
7
8 // Utilisation dans un programme
9
10 …
11 int m = min (i, j); // Remplacé par :m = ((i < j)? i : j);
12 … // (à la compilation)
PROG. 2.5 – Exemple de fonction inline.
En rajoutant le mot-cléinline lors de la définition de la fonction, la fonction est considérée comme inline : chaque appel fait à la fonction sera remplacé par le code source correspondant à la fonc-tion [PROG. 2.5]. On dit que la fonction est expanséeà son point d’appel. Quelques remarques :
1. Pour bénéficier de cette fonctionnalité, la fonction doit être définie (et non pas seulement dé-clarée) dans une interface, c’est-à-dire dans un fichier .H.
2. La spécification inline n’est qu’une recommandation faite au compilateur, qui peut décider ou non d’effectivement laisser cette fonction inline. En particulier, si le corps de la fonction est trop important, il y a peu de chances que la fonction reste inline ; il y a peu de gain aussi de toute façon, cette technique s’avérant rentable uniquement sur les fonctions comportant peu d’instructions.

Définition des variables

Contrairement au C qui impose de définir toutes les variables d’un bloc au début de ce bloc, C++ offre la possibilité de définir les différentes variables utilisées au fur et à mesure des besoins. Seule condition requise : une variable doit être soit déclarée, soit définie, avant de pouvoir être utilisée. VoirROG[P. 2.6] (et notamment les lignes 10 et 12) pour des exemples de définition de variables. Toutefois, dans un souci de lisibilité, il est conseillé de définir autant que possible les variables en début de bloc.
1 int main()
2 {
3 int a = 5;
4 int b = 4;
5 int c;
6
7 c = a * b;
8 b += c;
9
10 int j = 0;
11
12 for (int i = 0; i < c; i++)
13 j+= i;
14 }
PROG. 2.6 – Définition de variables en C++.

Les références

Les références permettent de bénéficier d’un mécanisme aliasd’ sur les variables. Le langage C avait déjà introduit la notion de pointeur sur variable, qui permet d’accéder à la valeur contenue dans une variable grâce à l’adresse de cette variable. Une référence est un nouveau nom donné à une variable existante, ce qui lui confère ce rôle d’alias. Une référence est également représentée par une adresse (un pointeur), mais s’utilise comme une variable : les opérations effectuées sur la référence sont en fait réalisées sur l’objet
référencé [PROG. 2.7]. Pour définir une référence Type: &nomRéf = variableÀRéférencer.

1 La conception objet 
1.1 Introduction
1.2 La modularité
1.2.1 Deux méthodes de conception de modules
1.2.2 Quelques critères de qualités
1.2.3 Les principes de définition
1.3 La réutilisabilité
1.3.1 Les principes de la réutilisabilité
1.3.2 De nouvelles techniques
1.4 Principes de conception objet
1.4.1 Introduction
1.4.2 La conception par objets
1.4.3 Détermination des objets
1.4.4 Conclusion
1.5 Résumé et terminologie
2 Introduction au langage C++ 
2.1 Historique
2.2 Implantation de modules en C++
2.3 Types de base
2.4 Commentaires
2.5 Structure d’un programme C++
2.6 Les fonctions
2.7 Définition des variables
2.8 Les références
2.9 Les constantes
2.10 Allocation dynamique de mémoire
2.11 La surcharge
2.12 Les entrées-sorties en C++
2.13 Les fonctions template
3 Les classes 
3.1 Définition
3.2 Utilisation
3.3 Les méthodes inline
3.4 Les constructeurs
3.5 Le destructeur
3.6 Méthodes constantes
3.7 Le mot-clé this
3.8 La surcharge
3.9 Les classes template
3.10 Les amis
3.11 Membres statiques
4 L’héritage 
4.1 Introduction
4.2 La dérivation
4.3 Redéfinition de méthodes
4.4 Le polymorphisme
4.5 La liaison dynamique
4.6 Les classes abstraites
5 La bibliothèque STL 
5.1 Introduction
5.2 Les containers
5.3 Les itérateurs
5.4 Les algorithmes
Annexes 
A Format des entrées-sorties
B Carte de référence STL
C Compléments
Bibliographie