Mini-Référence :
Introduction à la POO : Classes et Objets

Généralités

L'idée centrale à la base de la programmation objet est de regrouper, dans un même élément informatique (appelée «objet») les descriptions statique (les données) et dynamique (les opérations) issues de la modélisation d'une entité.
Le regroupement de ces descriptions se fait, dans un langage typé comme C++, au moyen de la définition d'un type abstrait de donnée complet, appelé classe, décrivant de manière abstraite et générique un ensemble (une classe) d'objets potentiels, et constituant un type (au sens du langage de programmation).

Le regroupement des données et des opérations est appelé encapsulation. (Pour être précis, l'encapsulation induit de plus une notion d'identité; l'objet ainsi construit est un tout, et possède une frontière... de cette frontière découle deux niveaux de perception de l'objet: le niveau externe, qui est la partie visible l'objet, depuis son l'extérieur (hors de la frontière), et le niveau interne, qui représente le corps de l'objet).

L'aspect statique, modélisé par des structures de données, est présent dans la classe sous la forme de spécification d'attributs, et l'aspect dynamique est lui représenté par la définition de méthodes (implémentant les opérations réalisables sur les objets).

OBJET = (valeur d') attributs + (accès aux) méthodes (+ identité)

Au niveau de la programmation, la création d'un objet appartenant à une classe donnée (i.e. une réalisation particulière de la classe) se fait par une simple déclaration de variable dont le type est celui implémenté par la classe. L'objet ainsi créé est appelé instance (de la classe), et le processus de 'création' est appelé instanciation

Concrètement une classe définit:

• les attributs possédés par chacune des instances;
• les méthodes applicables à chacune des instances;

Les classes en C++

La définition (i.e. déclaration) d'une classe en C++ s'effectue au moyen de la clause class est :

  class nom_classe
   {
     ...
   };

Notez le point-virgule (;) à la fin de la déclaration.

Une fois déclarée, une classe peut s'utiliser comme une autre variable :

nom_classe monobjet;

Exemple :

class Rectangle {
...
};

...

Rectangle r0;

Les attributs et les méthodes

Pour être intéressante, une classe doit contenir un certain nombre d'éléments (encapsulation) : les attributs (similaires aux champs d'une structure) et les méthodes, qui sont les fonctions propres à une classe.

La syntaxe de la déclaration des attributs est la syntaxe normale de déclaration des variables :

type nom_attribut;

Exemple :

class Rectangle {
   double longueur;
   double hauteur;
};

La syntaxe de la définition des méthodes d'une classe est la syntaxe normale de définition des fonctions, à l'exception de la clause optionnelle const, permettant de signaler une méthode de type «prédicat» (ne modifiant pas l'état interne de l'objet) par opposition aux méthodes «d'actions» (qui peuvent modifier des attributs de l'objet).

type_retour nom_methode ( type_arg1 nom_arg1,...) [const]
 {
    // corps de la méthode
    ...
 }

Exemple :

class Rectangle {
   double surface() const {
      return longueur * largeur;
   }
   void setLargeur(double l) {
      largeur = l;
   }
   double longueur;
   double largeur;
};

Accès aux attributs et aux méthodes

• L'invocation des méthodes définies pour une instance de nom monobjet se fait à l'aide d'expressions de la forme l:

  monobjet.nom_methode(val_arg1, ...)

• À l'intérieur du bloc définissant une méthode, l'accès aux attributs de l'objet pour lequel la méthode est invoquée se fait en spécifiant simplement le nom de l'attribut.
• Il existe un attribut particulier, toujours défini et propre à chaque instance : this.

  this est un pointeur sur l'instance courante de l'objet.

  Il peut en particulier être utilisé en cas d'ambiguïté de nom d'attribut (ou de méthode), par exemple dans le cas du masquage d'un attribut par un argument de méthode :

   this->nom_attribut

• En dehors des méthodes, ou pour accéder à un attribut d'une autre instance que celle pour laquelle la méthode à été invoquée, l'attribut nom_attribut de l'instance monobjet peut être référencé par une expression de la forme :

  monobjet.nom_attribut

  si tant est qu'il soit accessible de l'extérieur (c.-à-d. fait partie de l'interface)
• Les attributs et méthodes ne faisant pas partie de l'interface (c.-à-d. non accessibles hors de l'objet) se déclarent sous le mot clé private:
• Les attributs et méthodes faisant partie de l'interface (c.-à-d. accessibles hors de l'objet) se déclarent sous le mot clé public:

Exemple :

class Rectangle {
public:
   double surface()  {
      return longueur * largeur;
   }
   void setLargeur(double largeur) {
      this->largeur = largeur;
   }
private:
   double longueur;
   double largeur;
};

---

Dernière mise à jour : $Date: 2009-09-11 17:10:52 +0200 (Fri, 11 Sep 2009) $  ($Revision: 25 $)