par
© Roose Philippe - 2000
© Roose Philippe – 2000 2
Table des matières
1. Vocabulaire ____________________________________________________________3
2. Du C au C++ ___________________________________________________________3
2.1 Les commentaires _________________________________________________________ 3
2.2 Entrées/Sorties avec cin , cout et cerr _________________________________________ 3
2.3 Les flux__________________________________________________________________ 3
2.4 Définition de variables _____________________________________________________ 4
2.5 Visibilité des variables _____________________________________________________ 4
2.6 Les types composés ________________________________________________________ 4
2.7 Allocation mémoire________________________________________________________ 5
3. Les classes _____________________________________________________________5
3.1 Entête dans le .hpp ________________________________________________________ 5
3.2 Définition dans le .cpp______________________________________________________ 6
3.3 Instanciation et utilisation __________________________________________________ 6
3.4 Utilisation avec des pointeurs________________________________________________ 6
3.5 Fonctions ________________________________________________________________ 6
3.5.1 Passage de paramètres par référence _______________________________________________ 7
3.5.2 Paramètres par défaut __________________________________________________________ 7
3.5.3 Surcharge de fonctions _________________________________________________________ 7
3.6 Constructeurs, Destructeurs ________________________________________________ 8
3.7 Objets utilisés en paramètres ou en retour_____________________________________ 9
3.8 Adresse d’un objet : this____________________________________________________ 9
3.9 Constructeur par recopie ___________________________________________________ 9
3.10 Objets contenant d’autres objets_____________________________________________ 9
3.11 Surcharge/Surdéfinition d’opérateurs _______________________________________ 10
3.12 Héritage ________________________________________________________________ 10
3.12.1 Constructeurs – Destructeurs____________________________________________________ 11
3.12.2 Inclusion des fichiers__________________________________________________________ 12
3.12.3 Héritage multiple_____________________________________________________________ 12
3.12.4 Classes virtuelles _____________________________________________________________ 12
3.12.5 Polymorphisme ______________________________________________________________ 14
3.12.6 Classes abstraites_____________________________________________________________ 16
3.12.7 Membres ou fonctions statiques _________________________________________________ 16
4. Pointeurs et Arithmétique des pointeurs_____________________________________16
© Roose Philippe – 2000 3
1. Vocabulaire
Méthode : équivalent de fonction/procédure dans le langage objet.
Classe : structure rassemblant à la fois les données et les méthodes pour les manipuler (c’est l’équivalent du
type).
Objet : un objet est une instance de classe (équivalent de la variable).
Encapsulation : c’est le fait de ne n’accéder aux données que par le biais de méthode.
Héritage : les classes sont structurées de manière arborescente. L’héritage permet de définir des classes filles à
partir de classes mères.
Polymorphisme : permet à un objet d’une classe fille (héritée) de prendre la place d’un objet d’une classe mère.
Surcharge/Surdéfinition : permet d’avoirs plusieurs méthodes du même nom mais avec des paramètres
différents (nombre et/ou type).
2. Du C au C++
2.1 Les commentaires
Tout comme en C, le C++ permet d’utiliser les symboles /* et */ pour baliser un commentaire. Le C++ autorise
en plus le symbole // permettant d’ignorer ce qui suit jusqu’à la fin de la ligne.
Exemple :
/*
Ceci est un
Commentaire
Sur plusieurs lignes */
void main (void) { // ici débute le commentaire jusqu’à la fin de la ligne
{
…
}
2.2 Entrées/Sorties avec cin , cout et cerr
Alors qu’en C les entrées/sorties « classiques » s’effectuent à l’aide des fonctions scanf et printf, et bien qu’il
soit possible de les utiliser en C++, il est préférable d’utiliser une gestion par flot (ou flux, ou stream). Quatre
flots sont définis dans la librairie stream.h, nous allons en voir 3 :
2.3 Les flux
Comme pour le langage C, les instructions d’entrées/sorties ne font pas partie des instructions du langage. Elles
sont dans une librairie standardisée qui implémente les flots à partir de classes.
G cout, sortie standard
G cin, entrée standard
G cerr, erreur non tamponné
L'opérateur << permet d'envoyer des valeurs dans un flot de sortie, tandis que >> permet d'extraire des valeurs
d'un flot d'entrée.
Exemple :
#include <stream.h>
cin >> age >> date_naissance // saisie de l’age puis de la date de naissance
cout << « J’ai » << age << « ans » << endl ; // endl permet un retour à la ligne
L’intérêt des flots est une vitesse d'exécution plus rapide. La fonction printf doit analyser à l'exécution la chaîne
de formatage, tandis qu'avec les flots, la traduction est faite à la compilation. Nous le verrons plus tard, mais on
peut également utiliser les flux avec les types utilisateurs (surcharge possible des opérateurs >> et <<).
© Roose Philippe – 2000 4
2.4 Définition de variables
Il est possible en C++ de déclarer des variables n’importe où dans le code. Leur portée sera celle du bloc courant.
Cette manière de procéder permet de définir une variable le plus près possible de son utilisation améliorant ainsi
la lisibilité. Cette utilisation sera particulièrement appréciable dans les fonctions où de nombreuses variables
locales sont nécessaires. On pourra aussi initialiser un objet avec une valeur obtenue auparavant par calcul ou par
saisie.
Exemple :
cin >> i;
const int j = i; // définition d'une constante initialisée par saisie.
Contrairement au #define qui ne fait que remplacer chaque occurrence des chaînes mentionnées, le const possède
une analyse syntaxique ce qui lui permet d’être initialisé au cours de l’exécution.
2.5 Visibilité des variables
Il existe un opérateur noté : : permettant d’accéder à des variables globales en lieu et place de la variable locale
du même nom.
Exemple :
int i = 11;
void main() {
int i = 34;
{ int i = 23;
::i = ::i + 1;
cout << ::i << " " << i << endl;
}
cout << ::i << " " << i << endl;
Résultat de l’exécution :
12 23
12 34
Bien que l’on puisse y voir un intérêt certain, cette pratique est à proscrire. Elle n’améliore pas la lisibilité des
programme, et bien au contraire complique les modifications et/ou les mises à jour.
2.6 Les types composés
Tous comme en C, il est possible de définir de nouveaux types en définissant des structures (struct), des
énumérations (enum) ou des unions (union). La différence réside dans le fait qu’il n’est plus utile de spécifier le
mot clé typedef pour renommer un type.
Exemple :
struct ETUDIANT { // définition du type FICHE
char nom[50], prenom[50];
int age;
}; // en C, il faut ajouter la ligne typedef struct FICHE FICHE;
enum BOOLEEN { VRAI, FAUX }; // en C, il faut ajouter la ligne typedef enum BOOLEEN BOOLEEN;
BOOLEEN trouve;
trouve = FAUX; // OK
trouve = 0; // Produit une erreur car le C++ réalise une vérification de type (pas d’erreurs en C).
enum Semaine {DIMANCHE, LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI};
enum Drapeau { BLEU, BLANC, ROUGE };
Semaine j; // définition d'une variable de type Jour
Drapeau d ; // Définition d’une variable de type Drapeau
© Roose Philippe – 2000 5
j = LUNDI;
d = BLEU ;
c = j; // ERREUR en C++ (légal en C)
2.7 Allocation mémoire
En C, l’allocation de mémoire se réalise en utilisant les fameuses et merveilleuses ( !) fonctions malloc (et ses
variantes calloc, realloc) et free. Bien qu’il soit toujours possible de les utiliser en C++, deux nouvelles fonctions
on prit leur place : new et delete.
Exemple :
int *ptr_int
ptr_int = new int ; // allocation dynamique d’un entier
ptr_int = new int (5); // allocation dynamique d’un entier avec initialisation à 5
ptr_int = new int [5]; // allocation dynamique de 5 entiers
delete ptr_int ; // libération d’un entier
delete[ ] ptr_int ; // libération d’un tableau d’entiers.
//Tout ce qui est alloué avec new [ ] doit être libéré avec delete [ ].
Il est important de toujours libérer l’espace mémoire alloué à l’aide d’un new dès qu’il n’est plus utile. Ainsi, à
chaque new doit correspondre son pendant : delete. Dans le cas contraire, on prendra de la mémoire, sans jamais
la libérer, et dans le cas de programmes importants (ou par exemple lors d’allocations récursives) on pourrait
arriver à rapidement manquer d’espace mémoire.
3. Les classes
Une classe représente le modèle structurel d’un objet. Elle est composée :
G d’un ensemble d’attributs (ou champs, ou données membres) décrivant sa structure.
G d’un ensemble d’opérations (ou méthodes, ou fonctions membres) qui lui sont applicables.
L'encapsulation consiste à masquer l'accès à certains attributs et méthodes d'une classe. Elle est réalisée à l'aide
des mots clés :
G private : les membres privés ne sont accessibles que par les fonctions membres de la classe. La partie privée
est aussi appelée réalisation.
G protected : les membres protégés sont comme les membres privés. Mais ils sont aussi accessibles par les
fonctions membres des classes dérivées (voir l'héritage).
G public : les membres publics sont accessibles par tous. La partie publique est appelée interface.
Les mots réservés private, protected et public peuvent figurer plusieurs fois dans la déclaration de la classe.
3.1 Entête dans le .hpp
Tout comme il est préconisé de le faire en C pour une fonction, l’entête d’une classe est généralement placé dans
un fichier avec l’extension .hpp (.h pour le C). Voici la déclaration type d’une classe :
class maClasse {
private :
// on place ici les données et méthodes inaccessibles de l’extérieur (cette partie ne sera pas non plus accessible
par héritage - nous verrons cela plus loin).
int a ; // déclaration d’une variable privée
protected :
// partie visible uniquement par les classes dérivées
public :
// partie visible de l’extérieur, c’est ici qu’on place généralement les méthodes permettant d’accéder aux élément
de la section private.
int b ;
