PROGRAMMATION ORIENTE OBJET: NOTION DE CLASSE

I- INTRODUCTION
On attend d’un programme informatique
- l’exactitude (réponse aux spécifications)
- la robustesse (réaction correcte à une utilisation " hors normes ")
- l’extensibilité (aptitude à l’évolution)
- la réutilisabilité (utilisation de modules)
- la portabilité (support d’une autre implémentation)
- l’efficience (performance en termes de vitesse d’exécution et de consommation mémoire)
Les langages évolués de type C ou PASCAL, reposent sur le principe de la programmation structurée (algorithmes + structures de données)
Le C++ et un langage orienté objet. Un langage orienté objet permet la manipulation de classes. Comme on le verra dans ce chapitre, la classe généralise la notion de structure.
Une classe contient des variables (ou " données ") et des fonctions (ou " méthodes ") permettant de manipuler ces variables.
Les langages " orientés objet " ont été développés pour faciliter l’écriture et améliorer la qualité des logiciels en termes de modularité.
Un langage orienté objet sera livré avec une bibliothèque de classes. Le développeur utilise ces classes pour mettre au point ses logiciels.

Rappel sur la notion de prototype de fonction:
En C++, comme en C, on a fréquemment besoin de déclarer des prototypes de fonctions.
Par exemple, dans les fichiers d’en-tête (de type *.h), sont déclarés les prototypes des fonctions appelées par le programme.
Le prototype d’une fonction est constitué du nom de la fonction, du type de la valeur de retour, du type des arguments à passer

Exemples: void ma_fonction1()
void ma_fonction2(int n, float u) // prototype "complet"
void ma_fonction2(int, float) // prototype "réduit"

int ma_fonction3(char *x) // prototype "complet"
int ma_fonction3(char *) // prototype "réduit"
int ma_fonction4(int &u) // prototype "complet"
int ma_fonction4(int &) // prototype "réduit"

On utilise indifféremment, dans les fichiers d’en-tête, le prototype complet ou le prototype réduit.

II- NOTION DE CLASSE
Exemple (à tester) et exercice II-1 :
(il faut ajuster la temporisation aux performances de la machine utilisée)
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{x = abs; y = ord;}
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
void main()
{
point a,b;
a.initialise(1,4);
a.affiche();
tempo(10);
a.deplace(17,10);
a.affiche();
b = a; // affectation autorisee

tempo(15);
clrscr();
b.affiche();
getch() ;}
"point" est une classe. Cette classe est constituée des données x et y et des fonctions membres (ou méthodes)  " initialise ", " deplace ", " affiche ". On déclare la classe en début de programme (données et prototype des fonctions membres), puis on définit le contenu des fonctions membres.
Les données x et y sont dites privées. Ceci signifie que l’on ne peut les manipuler qu’au travers des fonctions membres. On dit que le langage C++ réalise l’encapsulation des données.
a et b sont des objets de classe "point", c’est-à-dire des variables de type "point".
On a défini ici un nouveau type de variable, propre à cet application, comme on le fait en C avec les structures.
Suivant le principe dit de " l’encapsulation des données ", la notation a.x est interdite.

Exercice II-2:
Utiliser la classe " point " précédente. Ecrire une fonction de prototype void test() dans laquelle on déclare un point u, on l’initialise, on l’affiche , on le déplace et on l’affiche à nouveau. Le programme principal main ne contient que l’appel à test.


Exercice II-3:
Ecrire une fonction de prototype void test(point &u) (référence) similaire. Ne pas déclarer de point local dans test. Déclarer un point local a dans le programme principal main et appeler la fonction test en passant le paramètre a.

Exercice II-4:
Ecrire une fonction de prototype point test() qui retourne un point. Ce point sera initialisé et affiché dans test puis déplacé et à nouveau affiché dans main.

III- NOTION DE CONSTRUCTEUR
Un constructeur est une fonction membre systématiquement exécutée lors de la déclaration d’un objet statique, automatique, ou dynamique.

On ne traitera dans ce qui suit que des objets automatiques.
Dans l’exemple de la classe point, le constructeur remplace la fonction membre initialise.
Exemple (à tester) et exercice II-5:
#include <iostream.h> // constructeur
#include <conio.h>
class point
{
int x,y;
public: point(); // noter le type du constructeur (pas de "void")
void deplace(int,int);
void affiche();
};
point::point() // initialisation par default
{x = 20; y = 10;} // grace au constructeur
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
void main()
{
point a,b; // les deux points sont initialisés en 20,10
a.affiche();
tempo(10);
a.deplace(17,10);
a.affiche();
tempo(15);
clrscr();
b.affiche();
getch() ;}
Exemple (à tester) et exercice II-6:
#include <iostream.h> // constructeur
#include <conio.h>
class point
{
int x,y;
public: point(int,int); // noter le type du constructeur (pas de "void")
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord) // initialisation par default
{x = abs; y = ord;} // grace au constructeur, ici paramètres à passer
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
void main()
{
point a(20,10),b(30,20); // les deux points sont initialises:a en 20,10 b en 30,20
a.affiche();
tempo(10);
a.deplace(17,10);
a.affiche();
tempo(15);
clrscr();
b.affiche();
getch() ;}
Exercice II-7: Reprendre l’exercice II-2, en utilisant la classe de l’exercice II-6

Exercice II-8: Reprendre l’exercice II-3, en utilisant la classe de l’exercice II-6

Exercice II-9: Reprendre l’exercice II-4, en utilisant la classe de l’exercice II-6



IV- NOTION DE DESTRUCTEUR
Le destructeur est une fonction membre systématiquement exécutée "à la fin de la vie " d’un objet statique, automatique, ou dynamique.
On ne peut pas passer de paramètres par le destructeur.

On ne traitera dans ce qui suit que des objets automatiques.
Exemple (à tester) et exercice II-10:
#include <iostream.h> // destructeur
#include <conio.h>
class point
{
int x,y;
public: point(int,int);
void deplace(int,int);
void affiche();
~point(); // noter le type du destructeur
};
point::point(int abs,int ord) // initialisation par default
{x = abs; y = ord;} // grace au constructeur, ici paramètres à passer
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
point::~point()
{cout<<"Frapper une touche...";getch();
cout<<"destruction du point x ="<<x<<" y="<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}

void test()
{
point u(3,7);
u.affiche();
tempo(20);
}
void main()
{point a(1,4);a.affiche();tempo(20);
test();
point b(5,10);b.affiche();
getch() ;}


V- ALLOCATION DYNAMIQUE
Lorsque les membres données d’une classe sont des pointeurs, le constructeur est utilisé pour l’allocation dynamique de mémoire sur ce pointeur.
Le destructeur est utilisé pour libérer la place.

Exemple (à tester) et exercice II-11:
#include <iostream.h> // Allocation dynamique de données membres
#include <stdlib.h>
#include <conio.h>
class calcul
{int nbval,*val;
public: calcul(int,int); // constructeur
~calcul(); // destructeur
void affiche();
};
calcul::calcul(int nb,int mul) //constructeur
{int i;
nbval = nb;
val = new int[nbval]; // reserve de la place
for(i=0;i<nbval;i++)val[i] = i*mul;
}
calcul::~calcul()
{delete val;} // abandon de la place reservee
void calcul::affiche()
{int i;
for(i=0;i<nbval;i++)cout<<val[i]<<" ";
cout<<"\n";
}
void main()
{
clrscr();
calcul suite1(10,4);
suite1.affiche();
calcul suite2(6,8);
suite2.affiche();
getch() ;}

VI- EXERCICES RECAPITULATIFS
Exemple (à tester) et exercice II-12:
Cet exemple ne fonctionne qu’en environnement DOS. Il utilise les fonctions graphiques classiques du TURBO C. On crée une classe " losange ", les fonctions membres permettent de manipuler ce losange.

#include <graphics.h>
#include <conio.h>
#include <iostream.h>
#include <dos.h>
class losange
{
int x,y,dx,dy,couleur;
public:
losange();
void deplace(int,int,int);
void affiche();
void efface();
};
losange::losange() // constructeur
{x=100;y=100;dx=60;dy=100;couleur=BLUE;}
void losange::deplace(int depx,int depy,int coul)
{x=x+depx;y=y+depy;couleur=coul;}
void losange::affiche()
{int tab[10];
tab[0]=x;tab[1]=y;tab[2]=x+dx/2;tab[3]=y+dy/2;
tab[4]=x;tab[5]=y+dy;tab[6]=x-dx/2;tab[7]=y+dy/2;
tab[8]=x;tab[9]=y;
setfillstyle(SOLID_FILL,couleur);
fillpoly(5,tab);
}
void losange::efface()
{int tab[10];
tab[0]=x;tab[1]=y;tab[2]=x+dx/2;tab[3]=y+dy/2;
tab[4]=x;tab[5]=y+dy;tab[6]=x-dx/2;tab[7]=y+dy/2;
tab[8]=x;tab[9]=y;
setcolor(getbkcolor()); // pour effacer le contour
setfillstyle(SOLID_FILL,getbkcolor());
fillpoly(5,tab);
}
void init_graph()
{
int gd,gm;
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\cplus\\bgi");
setbkcolor(YELLOW);
}
void main()
{
losange l;
init_graph();
l.affiche();
getch();closegraph();
}
Exercice II- 13: Modifier le programme principal de sorte de faire clignoter le losange tant que l’utilisateur n’a pas appuyé sur une touche.

Exercice II- 14: Modifier le programme principal de sorte de déplacer le losange d’une position à une autre position, tant que l’utilisateur n’a pas appuyé sur une touche.



VII- CORRIGE DES EXERCICES
Exercice II-2:
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{x = abs; y = ord;}
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
void test()
{
point u;
u.initialise(1,4);u.affiche();
tempo(10);
u.deplace(17,10);u.affiche();
}
void main()
{test();getch() ;}
Exercice II-3:
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{x = abs; y = ord;}
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
void test(point &u)
{
u.initialise(1,4);u.affiche();
tempo(10);
u.deplace(17,10);u.affiche();
}
void main()
{point a;test(a);getch() ;}
Exercice II-4:
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{x = abs; y = ord;}
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
point test()
{point u;
u.initialise(1,4);u.affiche();return u;}
void main()
{point a;
a = test();
tempo(10);
a.deplace(17,10);a.affiche();getch() ;}
Exercice II-7:
#include <iostream.h>
#include <conio.h>
class point
{
int x,y;
public: point(int,int); // noter le type du constructeur (pas de "void")
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord) // initialisation par default
{x = abs; y = ord;} // grace au constructeur, ici paramètres à passer
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}

void test()
{
point u(1,4);
u.affiche();
tempo(10);
u.deplace(17,10);
u.affiche();
}
void main()
{test();getch() ;}
Exercice II-8:
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: point(int,int); // noter le type du constructeur (pas de "void")
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord) // initialisation par default
{x = abs; y = ord;} // grace au constructeur, ici paramètres à passer
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}

void test(point &u)
{
u.affiche();
tempo(10);
u.deplace(17,10);u.affiche();
}
void main()
{point a(1,4);test(a);getch() ;}

Exercice II-9:
#include <iostream.h> // les classes
#include <conio.h>
class point
{
int x,y;
public: point(int,int); // noter le type du constructeur (pas de "void")
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord) // initialisation par default
{x = abs; y = ord;} // grace au constructeur, ici paramètres à passer
void point::deplace(int dx,int dy)
{x = x+dx; y = y+dy;}
void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
void tempo(int duree)
{float stop ;stop = duree*10000.0;for(;stop>0;stop=stop-1.0);}
point test()
{point u(5,6);
u.affiche();return u;}
void main()
{point a(1,4);
a.affiche();
tempo(15);
a = test();
tempo(10);
a.deplace(17,10);a.affiche();}
Exercice II-13:
void main()
{
losange l;
init_graph();
while(!kbhit())
{
l.affiche(); delay(500);
l.efface(); delay(500);
}
getch();closegraph();
}
Exercice II-14:
void main()
{
losange l;
init_graph();
while(!kbhit())
{
l.affiche(); delay(500);l.efface();
l.deplace(150,150,RED);
l.affiche();delay(500);l.efface();
l.deplace(-150,-150,BLUE);
}
getch();closegraph();
}

cpp2.zip