Date post: | 04-Apr-2015 |
Category: |
Documents |
Upload: | jolene-leduc |
View: | 110 times |
Download: | 5 times |
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