Leçon 1 : notion d’objet

IUP Génie InformatiqueBesançon

Méthode et Outils pour la Programmation

Françoise Greffier

Université de Franche-Comté

notion d’objet

Classe / instance

Interface / implantation

Classification des méthodes

Constructeur(s), destructeur

Méthodes implicites

pointeur this

Une CLASSE est un MODELE

saisir

afficher

périmètre

Méthode

La classe rectanglefournit des méthodes

Une application

Utilise une (ou plusieurs)classe(s)#include ...

Par activation des méthodes fournies par la classe

R.saisir()

Classe et instance de classe

Une classe

est un modèle

Méthodes

class rectangle{. . .

Une application

Rectangle

R

Crée une instance appelée RUne instance est un représentant du modèle

# include "rectangle.h"void main (void){rectangle R;

Une classe est définieà la compilation del’application

Une instance est créée à l ’exécution de l’application

ACTIVATION D ’UNE METHODE

# include "rectangle.h"void main (void){rectangle R;R.saisir ( ); . . .

Toute méthode

est déclenchée par une instance

SYNTAXE :identificateur instance . Appel méthode

CONFIDENTIALITE

# include "rectangle.h"void main (void){rectangle R; R.saisir ( );. . .

Application

Seule partie

accessible

La seule partie accessible pour une application utilisatriced ’une classe est la section publicde cette classe.

class rectangle{public : rectangle ( void);//constructeur par défaut void saisir (void);

. . .};

Implantation

classe rectangle

PRINCIPE de confidentialité

Principe :Seules les informations déclarées publiques dans une classe sont accessibles à l’utilisateur de cette classe.

pour garantir le fonctionnement correct d’un objet

# include "rectangle.h"void main (void){rectangle R;R.saisir ( );

R.lo = 4; . . .

Instruction illicite

TOUT LE RESTE EST DU DOMAINE PRIVE

(NON ACCESSIBLE DE l ’EXTERIEUR).

REGLES D ’ACCESSIBILITE

Application Classe

Les membres d ’une classeont accès à tousles autres membres de cette classe

Seuls les membresde la section publicde (des) classe(s)utilisées(s)sont accessibles.

DISTINCTION entre:

les fonctionnalités d ’un objet : INTERFACE

et le codage de celles-ci : IMPLANTATION

INTERFACE /IMPLANTATION

INTERFACE d ’une classeest une partie conceptuelle qui est distincteet qui précède l ’IMPLANTATION de celle-ci.

Interface = mode d ’emploi= protocole d ’utilisation= partie descriptive

Implantation= représentation physique de l ’objet= code des méthodes

CONCEVOIR UNE CLASSE

Etape 1 : spécifier une méthodeExemple : saisie du rectangle

class rectangle{public :

//IC est construitevoid saisir (void);// longueur et largeur de IC sont saisies

CODER UNE CLASSE

Etape 2 : implanter cette méthodeExemple : méthode de saisie du rectangle

class rectangle{public :

. . .private :double lo;double la;

};

void rectangle::saisir(void){ cin >> lo;

cin >> la; }

# include <iostream.h>

Organisation d'une INTERFACE

L ’interface d ’une classe est la partie visible

depuis l ’extérieur, par l ’utilisateur de la classe.

Elle décline les méthodes fournies par la classe.

Facteur de qualité :

Une classification des méthodes permettra

à l ’utilisateur de la classe de trouver facilement

les méthodes dont il a besoin.

CONSTRUCTEUR(S)

Un constructeur est une méthode qui permet de créer une instance et qui peut aussi initialiser l’état de l'instance créée

SYNTAXE : prototype d ’un constructeur nom de la classe (paramètres(s) éventuel(s))

Exemple : rectangle(void);

Toute classe comprend au moins un constructeur

CONSTRUCTEUR(S)

Il existe trois types de constructeur :

constructeur par défaut

constructeur par initialisation

constructeur par copie

Constructeur par défaut SYNTAXE : prototype du constructeur par défaut

nom de la classe (void);

# include "rectangle.h"void main (void){rectangle R;

. . .Appel du constructeur par défaut

R.loMémoire statique

R.la

???

???

rectangle (void); // IC est construite vide

Constructeur par initialisation

SYNTAXE : prototype du constructeur par initialisation nom de la classe (paramètres d ’initialisation);Exemple :

# include "rectangle.h"void main (void){rectangle R (10,6);

. . .Appel du constructeur par initialisation

R.loMémoire statique

R.la

10

6

rectangle (double x, double y); //IC est construite et lo=x, la =y

Constructeur par copie

SYNTAXE : prototype du constructeur par copie nom_classe(const nom_classe&);

Exemple :

Le constructeur par copie peut jouer un des rôles suivants :• Création d ’une instance par recopie d ’une autre instance• Transmission d'argument par valeur• Retour d'une valeur par une fonction

rectangle (const rectangle& B); //IC est construite IC=B

Constructeur par copie

# include "rectangle.h"

void main (void)

{rectangle R (10,6);

rectangle R2 (R);

rectangle R3 =R;

. . .

Appel du constructeur par copie

R.loMémoire statique

R.la

10

6

R2.lo 10 R3.lo 10

R2.la 6 R3.la 6

Constructeur par copie

On surchargera (redéfinira) le constructeur par copie lorsque la copie des valeurs des attributs ne réalisera pas une « vraie » copie (ex:gestion par pointeurs). Dans ce cas il sera impératif de redéfinir le constructeur par copie, car l'opération implicite de copie est déclenchée automatiquement dans de nombreux contextes.

IMPLANTATION

Cette méthode existe par défaut dans toute classe.Le compilateur fait par défaut une copie des valeursdes attributs de l'instance.

Cette copie est satisfaisante pour dupliquer la longueur et la largeur d'un rectangle.

DESTRUCTEUR

SYNTAXE : prototype du destructeur ~ nom_classe (void);

Exemple :

Le destructeur joue le rôle suivant :Une instance a une durée de vie correspondant au bloc dans lequel elle est déclarée. En fin de bloc l'instance est détruite par un appel automatique du destructeur. L ’exécution du destructeur génère une remise en l ’état des ressources (espace mémoire) utilisée à la création de l ’instance.

~ rectangle (void); //destructeur

DESTRUCTEUR : APPEL

# include "rectangle.h"

void main (void)

{rectangle R;

R.saisir ( );

. . .

} Appel du destructeur sur

l ’instance R

DESTRUCTEUR : implantation

Autre cas : gestion dynamique de la mémoireLorsque le constructeur induit une allocation de mémoire (new en C++) alors le destructeur comprend des instructions (delete en C++) permettant de libérer la mémoire précédemment allouée.

Action vide pour la classe rectangle

car il n'y a pas de ressources mémoire particulières à gérer.

rectangle :: ~ rectangle (void)

{ }

METHODES IMPLICITES

Les méthodes suivantes sont prédéfinies pour chaque classe:• constructeur par défaut• constructeur par copie• destructeur• affectation• tests d ’égalité

# include "rectangle.h"

void main (void)

{rectangle R,R2;

R.saisir ( );

R2=R; //affectation

}

Les méthodes implicites peuvent être redéfinies. Il est parfois impératif de le faire (gestion dynamique de la mémoire).

Le pointeur this

class rectangle{public ://ICvoid afficher (void);//longueur et largeur de IC sont affichées

Remarque : il n’est pas nécessaire d ’expliciter un paramètre représentant l ’instance courante (IC).

Mécanisme : chaque méthode a un premier paramètre implicite pour représenter l ’instance courante.Ce paramètre a pour identificateur (en C++) : thisthis désigne un pointeur sur IC

Le paramètre this

void rectangle::afficher (void) {cout << lo; cout << la; }

//cout << this -> lo;//cout << this -> la;

ILLUSTRATION : implantation de la méthode afficher