Les classes en C++
Avec le C++ la possibilité d'utiliser des objets est apparue.
La programmation objet facilite grandement le codage de certaines choses car elle les rend plus faciles et moins complexes.
Tout d'abord une petite introduction au lexique de la programmation objet :

Les classes
Elles représentent des objets et donc des entités, par exemple : Un vecteur, un bouton, une voiture, un rectangle.
Les instances
Ce sont les objets créés à partir d'une classe en le déclarant, par exemple : Rectangle monPetitRectangle; monPetitRectangle sera une instance de la classe Rectangle.
Les méthodes
Les méthodes sont des fonctions propres à une classe. Une fonction est un bloc de code auquel on peut envoyer et recevoir des informations. Par exemple on pourrait imaginer une méthode "Afficher()" à une classe CompteEnBanque qui afficherait les données du compte.
Les attributs
Ce sont les variables propres à la classe. Par exemple une classe Rectangle aurait comme propriétés une longueur et une largeur.
Les propriétés
Ce sont les méthodes utilisées pour lire/écrire les attributs de la classe. Celles-ci sont donc publiques (accessibles depuis une autre classe).

Un objet en programmation est une entité propre, prenons l'exemple d'une voiture :
Une voiture à un moteur, une couleur, un nombre de sièges.
Ces variables sont appelées attributs en programmation objet. Les attributs sont privés et propres aux objets.

Une voiture peut aussi avancer.
Cette "fonction" de la voiture est appelée méthode.

Pour interagir avec les attributs on fait appel à des propriétés. Dans certains langages comme en C++ il n'y a pas de type propriété comme en C# par exemple. Donc nous ferons appel à des méthodes.
Pour créer des objets et les initialiser nous faisons appel à des constructeurs. les constructeurs sont appelés par le mot clé new suivi d'un espace et du nom de la classe avec les paramètres entre parenthèses.

Après la théorie, la pratique! Prenons l'exemple de notre voiture :
Voici donc ce qui "déclare" notre classe au compilateur.
  1. class Voiture{

  2. /*On utilise "private:" pour indiquer au compilateur que les variables qui seront précédemment créées devront être privées. C'est à dire qu'elles pourront être lues et modifiées que par la classe elle-même et pas par un autre objet. Si notre classe est appellée à être héritée par une autre, il faudra mettre ces attributs en "protected" pour que la classe qui héritera de ces attributs puissent les modifier.*/

  3. private:

  4. Couleur *_couleur;

  5. Moteur *_moteur;

  6. int _positionX, _positionY;

  7. int _nombrePlaces;

  8.  

  9. /*On utilise "public:" pour indiquer au compilateur que les attributs/méthodes suivantes sont publiques, c'est à dire qu'elles peuvent être appelées depuis un autre objet.*/

  10. public:

  11.     /*Constructeurs*/

  12. /*Le premier constructeur est un constructeur vide, on l'utilisera pour créer une voiture en plaçant des paramètres par défaut. Un constructeur porte le même nom que la classe qui le contient.*/

  13.  

  14. Voiture();

  15.  

  16. /*Le deuxième constructeur prend en compte des arguments, comme cela, on pourra directement "paramétrer" notre voiture avec ce constructeur. Notez qu'une classe peut utiliser une autre classe, on utilisera donc une instance d'une classe nommée "Couleur" et une autre de "Moteur"*/

  17.  

  18. Voiture(Couleur couleur, int nombrePlaces, Moteur moteur);

  19.     /*Propriétés*/

  20.  

  21. void setCouleur(Couleur couleur);

  22. void setMoteur(Moteur moteur);

  23. void setNombrePlaces(int nombrePlaces);

  24. void setPosition(int positionX,int positionY);

  25. Couleur getCouleur();

  26. Moteur getMoteur();

  27. int getNombrePlaces();

  28. int getPositionX();

  29. int getPositionY();

  30.     /*Méthodes*/

  31.  

  32. void avancer(int x,int y);

  33. };


Ensuite il faut décrire les méthodes dans un fichier normalement nommé "Voiture.cpp". Pour indiquer au programme que nous décrivons la méthode/propriété de la classe "Voiture" il faut placer "Voiture::" devant le nom des méthodes/propriétés :

  1. #include "Voiture.h"

  2.  

  3. Voiture::Voiture(){

  4.    _couleur = new Couleur();

  5.    _moteur = new Moteur();

  6.    _positionX=0;

  7.    _positionY=0;

  8.    _nombrePlaces=0;

  9. }

  10. Voiture::Voiture(Couleur couleur, int nombrePlaces, Moteur moteur){

  11.    _couleur=couleur;

  12.    _nombrePlaces=nombrePlaces;

  13.    _moteur=moteur;

  14. }

  15. void Voiture::setCouleur(Couleur couleur){

  16.    _couleur=couleur;

  17. }

  18. void Voiture::setMoteur(Moteur moteur){

  19.    _moteur=moteur;

  20. }

  21. void Voiture::setNombrePlaces(int nombrePlaces){

  22.    _nombrePlaces=nombrePlaces;

  23. }

  24. void Voiture::setPosition(int positionX,int positionY){

  25.    _positionX=positionX;

  26.    _positionY=positionY;

  27. }

  28. Couleur Voiture::getCouleur(){

  29.    return _couleur;

  30. }

  31. Moteur Voiture::getMoteur(){

  32.    return _moteur;

  33. }

  34. int Voiture::getNombrePlaces(){

  35.    return _nombrePlaces;

  36. }

  37. int Voiture::getPositionX(){

  38.    return _positionX;

  39. }

  40. int Voiture::getPositionY(){

  41.    return _positionY;

  42. }

  43. void Voiture::avancer(int x,int y){

  44.    _positionX+=x;

  45.    _positionY+=y;

  46. }



Maintenant voici comment notre objet peut s'utiliser :
  1.  

  2. #include "Voiture.h"

  3.  

  4. int main(void){

  5. //On déclare une instance de Voiture nommée maVoiture

  6.    Voiture *maVoiture;

  7.  

  8. //On initialise l'instance de la classe Voiture avec le constructeur par défaut

  9.    maVoiture= new Voiture();

  10.  

  11. //On appelle la méthode avancer de maVoiture pour la faire avancer jusqu'à la position (1;1)

  12.    maVoiture->avancer(1,1);

  13.  

  14. //On quitte le programme

  15.    return 0;

  16. }

Anglais Français

©Oliverro 2006 | Valid XHTML 1.0 Transitional | Valid CSS