Méthodes spécifiques :

- Constructeur :
Un constructeur est une fonction membre dépourvue de type de retour, ayant
le
même nom que la classe et appelé automatiquement à l'instanciation de cette
dernière.
Il existe trois types de constructeurs :

- Constructeur sans paramètres (par défaut) :

Le constructeur sans paramètres est le constructeur qui n'admet pas de

paramètres.
Il est généré implicitement lorsque le programmeur ne definit aucun
constructeur pour
la classe.

- Constructeur d'initialisation (parametré) :

C'est un constructeur qui a au moins un paramètre.

Il permet d'initialiser l'objet en cours de création par ses
paramètres.

- Constructeur par copie (par recopie) :

C'est un constructeur qui permet d'initialiser un nouvel objet par un

autre
objet existant de la même classe.
Il peut avoir comme prototype :

NomClasse(const NomClasse &);

NB : A l'instanciation d'une classe, on appel implicitement un

constructeur pour initialiser
l'objet en cours de création.

Exemple :
point(const point &);

Surcharge de constructeurs :
Est la création de plusieurs constructeurs pour une même classe, ainsi
on a autant de manières
d'instancier cette classe que le nombre de constructeur.

Exemple : Créer tous les constructeurs pour la classe point en

remplaçant la fonction membre
initialise puis tester ces

- Destructeur :
Un destructeur est une fonction membre dépourvue de type de retour, ayant
le nom de la classe
précedé par un tilde (~) et appelé implicitement lors de la destruction de
tout objet.
Il a pour rôle de libérer toutes les ressources crées (fichier ouvert,
allocation dynamique de
mémoire,...).
Exemple :
Créer pour la classe point un destructeur qui affiche les
coordonnées de chaque instance
de cette classe qui tend vers la destruction

NB : Le destructeur ne reçoit pas de paramètres ainsi on ne peut pas

surcharger le destructeur*.

- Accesseurs et Mutateurs

- Accesseurs (getters) :
Un accesseur est une fonction membre qui permet l'accès en lecture
d'une donnée membre en dehors
de sa visibilité (portée). La syntaxe de l'accesseur est la suivante :
type get nomAttribut()
{
return nomAttribut;
}
NB : type doit être le même que le type de retour.

- Mutateurs (setters) :
Un mutateur est une fonction membre qui permet l'accès en écriture
d'une donnée membre en dehors
de sa visibilité (portée). La syntaxe du mutateur est la suivante :
void set nomAttribut(type valeur)
{
nomAttribut = valeur;
}

- Exemple :
Créer tout les accesseurs et mutateurs pour la classe point puis
tester les.

NB : this represente dans la classe le pointeur de l'objet en cours

d'utilisation.

Exemple :
Créer la classe rectangle sachant qu'un rectangle est caractérisé
par sa longueur
et sa largeur. Puis définissez les fonctions membres suivantes :
- Le constructeur d'initialisation à deux paramètres;
- La méthode void perimetre() qui affiche le périmètre d'un
rectangle;
- La méthode void surface() qui affiche la surface d'un
rectangle;
- Ensuite, tester la classe rectangle;