c++ : classes et objets

1. Introduction au C++
Chap 2 : classes et objets
M. DIENG Abdoulaye

2. Classes et objets
1. Abstraction
2. Définition d’une classe
3. Déclaration d’un attribut
4. Définition d’une méthode
5. Instanciation d’une classe
6. Constructeurs
7. Accès aux membres d’un objet
8. Les membres de classe
9. Destructeur
10. L’encapsulation

3. Abstraction
hauteur : 5
largeur : 2,5
surface= 12,5
hauteur : 3
largeur : 5,5
surface= 16,5
hauteur : 3,5
largeur : 3,5
surface= 12,25
hauteur :
largeur :
surface= hauteur x largeur
spécifique
a
b
s
t
r
a
c
t
i
o
n
générique

4. Abstraction
• Le processus d’abstraction consiste à identifier et à regrouper des
caractérisations et des traitements communs à la totalité d’un
ensemble d’entités ou de concepts variés.
• Ces caractérisations et traitements constituent une description
générique des éléments de l’ensemble considéré.
• Une représentation abstraite commune de ces éléments permet
d'en simplifier la manipulation.
• Exemple :
1) les notions de «largeur» et «hauteur» sont des propriétés
communes à l’ensemble des rectangles ;
2) de même que le calcul de la «surface» d’un rectangle

5. Abstraction
Objet ≈ variable du type représenté par la
classe.
Classe
(description générique abstraite)
hauteur :
largeur :
surface= …
Le processus d’abstraction => la notion de classe
Classe = factorisation des caractérisations et
mécanismes communs
Classe = moule pour la création des objets
Classe ≈ type
Objet
(réalisation spécifique concrète)

6. Définition d’une classe
Une syntaxe possible pour la définition d’une classe est :
class <nom de classe> {
public :
// déclaration des attributs
...
// prototypes et définitions des méthodes
...
};// N’oubliez pas ce ; après l'accolade

7. Déclaration d’un attribut
• La syntaxe de déclaration des attributs est la syntaxe
classique de déclaration des variables :
<type> <identificateur d’attribut>;
• Exemple :
float hauteur;
float largeur;
• Contrairement aux variables simples, les attributs ne
peuvent être directement initialisés lors de leur
déclaration.
• Pour réaliser ces initialisations, on définira des méthodes
particulières, appelées constructeurs

8. Définition d’une méthode
• La syntaxe de définition des méthodes est la syntaxe classique de
définition des fonctions
• La définition d’une méthode peut se faire soit dans celle de la classe
(méthode inline), soit séparément.
• Dans le second cas, l’opérateur de résolution de portée ::est
nécessaire pour désigner la classe.
• Syntaxe:
<typeRslt> [<nomClasse>::]<nomMethode>(arg,…){
<corps de la méthode>
}
• Exemple :
float Rectangle::surface(){
return (hauteur*largeur);// attributs visibles
}

9. Accès à un attribut masqué
• Si, dans une méthode, un attribut est masqué il peut tout de
même être référencé, à l’aide du mot-clef this
• La syntaxe est alors la suivante :
this -> <nom de l’attribut>
ou (*this) . <nom de l’attribut>
• Exemple :
void changeHauteur(float hauteur){
if (hauteur > 0){
this->hauteur = hauteur;
}
}
• this est un pointeur qui pointe sur l’objet en cours d’exécution
au moment de l’appel de la méthode.

10. Exemple d’une classe
class Rectangle{
public:
// déclaration des attributs
float hauteur;
float largeur;
// prototypage et définition des méthodes
float surface(){
return (hauteur * largeur);
}
void changeHauteur(float hauteur){
if (hauteur > 0)
this->hauteur = hauteur;
}
};

11. Instanciation d’une classe
• Les classes sont considérées comme des types à part entière.
• Instanciation statique :
<NomClasse> <nomInstance>;
• Instanciation dynamique :
<NomClasse> *<nomPointeur> = new <NomClasse>;
• Exemples :
Rectangle r1;
Rectangle *p_rect=new Rectangle;

12. Constructeurs (1/4)
• Un constructeur est une méthode particulière qui est appelée
lors de la création d’un objet.
• Un constructeur porte le même nom que la classe
• Un constructeur peut admettre zéro, un ou plusieurs
arguments et n’a pas de valeur de retour (même pas void).
• Sa tâche principale est d’initialiser les attributs de l’objet.
• Il peut aussi ouvrir des fichiers ou des connexions.
• Si une classe ne définit pas explicitement de constructeur, un
constructeur par défaut sans arguments et qui n’effectue
aucune initialisation particulière est invoquée.
• Ce constructeur par défaut ne peut plus être invoqué s’il existe
un constructeur explicite
• Une classe peut admettre plusieurs constructeurs.

13. Constructeurs (2/4)
• Le corps d’un constructeur est précédé d’une section
optionnelle introduite par «:», spécifiquement réservée à
l’initialisation des attributs.
• Il est bien sûr possible de changer la valeur d’un attribut
initialisé ou d’affecter une valeur à un attribut non initialisé
dans le corps du constructeur.
• Un constructeur peut admettre des arguments pour lesquels
une valeur par défaut est spécifiée.

14. Constructeurs (3/4)
• Syntaxe :
NomClasse(<arguments>)
: <attribut1>(<valeur1>),
...
<attributn>(<valeurn>)
{
// autres opérations
}

15. Constructeurs (4/4)
• Exemple 1 :
Rectangle(float h, float l=10)
: hauteur(h),
largeur(l)
{ }
• Exemple 2 :
Rectangle(float h, float l)
: hauteur(h)
{
float t(2*l - h % 2);
largeur = t;
}
• Exemple 3 :
Rectangle(float dim)
: hauteur(dim),
largeur(dim)
{ }

16. Initialisation d’un objet avec un
constructeur
• La syntaxe de la déclaration avec initialisation d’une instance
est identique à celle d’une déclaration avec initialisation d’une
variable ordinaire.
• Syntaxes:
<NomClasse> <NomInstance>(val1, val2,...);
<NomClasse> * <NomPointeur> = new <NomClasse> (val1, val2,...);
• NB : le nombre et les types des valeurs d’initialisation doivent
se conformer à un constructeur
• Exemples :
Rectangle r1(8.5,11);
Rectangle r2(12.5);
Rectangle *p_rect=new Rectangle(1.5,3);

17. Accès aux membres d’un objet
• Accès à un attribut :
<nomInstance>.<nomAttribut>
<nomPointeur> -> <nomAttribut>
Exemples :
r1.largeur = 13;
p_rect->hauteur = 5;
• NB : le principe de l’encapsulation interdit l’accès direct à un
attribut.
• Accès à une méthode :
<nomInstance>.<nomMéthode>([<arg1>, ...])
<nomPointeur> -> <nomMéthode>([<arg1>, ...])
Exemple :
cout << "La surface du premier rectangle est de "
cout << r1.surface();

18. Attribut de classe
• Attribut qui existe même si aucun objet de la classe n’est créé.
Exemple : le nombre de rectangles créés
• Déclaré en se servant du mot clé static
Exemple : static unsigned int nbRectanglesCrees;
• Accessible en le préfixant du nom de la classe suivi de ::
Exemple : Rectangle::nbRectanglesCrees
• Obligatoirement initialisé lors de sa définition (à l’ext. de la classe)
Exemple : unsigned int Rectangle::nbRectanglesCrees=0;
• Un attribut de classe est appelé constante de classe lorsque sa
valeur initiale est fixe durant toute l’exécution du programme
• Une constante de classe est déclarée avec le mot clé const
Exemple de déclaration : static const float TVA;
Exemple de définition : const float Voiture::TVA=0.18;

19. Méthode de classe
• Une méthode de classe exécute une action indépendante
d’une instance particulière de la classe
• Elle permet de manipuler des attributs ou des constantes de
classe
• Elle ne doit pas manipuler une variable d’instance
• Elle est déclarée avec le mot clé static.
• Elle est accessible comme une variable de classe

20. Destructeur
• Un destructeur est une méthode particulière qui est invoquée
automatiquement en fin de vie d’une instance (sortie du bloc
où elle a été déclarée ou destruction explicite par delete).
• Un destructeur porte le même nom (précédé du caractère
« ~ ») que la classe et n’a ni de valeur de retour, ni argument.
• Son rôle est d’assurer la libération des ressources (portion de
mémoire, fichier, BDD, etc) éventuellement mobilisées.
• Toute classe admet exactement un seul destructeur.
• Si une classe ne définit pas explicitement de destructeur, un
destructeur par défaut est invoquée.

21. Encapsulation (1/2)
• L'encapsulation est un mécanisme consistant à empêcher
l'accès aux données par un autre moyen que les services
(méthodes) proposés :
o chaque objet = boîte noire pour ses utilisateurs
o les utilisateurs n'ont accès qu’à l'interface publique
• Ce mécanisme permet de :
o garantir l'intégrité des données contenues dans l'objet ;
o simplifier l'utilisation des objets en masquant l'ensemble
des attributs et des méthodes qui sont utiles simplement au
fonctionnement interne des objets.

22. Encapsulation (2/2)
• L’encapsulation est implémentée par trois niveaux de
protections pour les membres d’une classe.
• Dans l’ordre croissant de protection, on a :
1) public : le membre est accessible de partout
2) protected : le membre n’est accessible que dans la classe
dans laquelle il est déclaré et dans les classes dérivées (à
voir) de celle-ci.
3) private : le membre n’est accessible que dans la classe dans
laquelle il est déclaré.
• Par défaut, les membres d’une classe sont privés
• Les « accesseurs » sont des méthodes publiques qui
permettent de consulter les attributs privés si nécessaire.
• Les « mutateurs » sont des méthodes publiques qui
permettent de modifier (sous contrôle) les attributs privés si
nécessaire.