Introduction à la Programmation Orientée Objet

Comme leur nom l'indique, les constructeurs servent à construire l'objet en mémoire. Un constructeur va donc se charger de mettre en place les données, d'associer les méthodes avec les champs et de créer le diagramme d'héritage de l'objet, autrement dit de mettre en place toutes les liaisons entre les ancêtres et les descendants.

Il faut savoir que s'il peut exister en mémoire plusieurs instances d'un même type objet, autrement dit plusieurs variables du même type, seule une copie des méthodes est conservée en mémoire, de sorte que chaque instance se réfère à la même zone mémoire en ce qui concerne les méthodes. Bien entendu, les champs sont distincts d'un objet à un autre. De fait, seules les données diffèrent d'une instance à une autre, la "machinerie" reste la même, ce qui permet de ne pas occuper inutilement la mémoire.

Certaines remarques sont à prendre en considération concernant les constructeurs.

• Un objet peut ne pas avoir de constructeur explicite. Dans ce cas, c'est le compilateur qui se charge de créer de manière statique les liens entre champs et méthodes.
• Un objet peut avoir plusieurs constructeurs : c'est l'utilisateur qui décidera du constructeur à appeler. La présence de constructeurs multiples peut sembler saugrenue de prime abord, leur rôle étant identique. Cependant, comme pour toute méthode, un constructeur peut être surchargé, et donc effectuer diverses actions en plus de la construction même de l'objet. On utilise ainsi généralement les constructeurs pour initialiser les champs de l'objet. À différentes initialisations peuvent donc correspondre différents constructeurs.
• S'il n'est pas nécessaire de fournir un constructeur pour un objet statique, il devient obligatoire en cas de gestion dynamique, car le diagramme d'héritage ne peut être construit de manière correcte que lors de l'exécution, et non lors de la compilation.

Le destructeur est le pendant du constructeur : il se charge de détruire l'instance de l'objet. La mémoire allouée pour le diagramme d'héritage est libérée. Certains compilateurs peuvent également se servir des destructeurs pour éliminer de la mémoire le code correspondant aux méthodes d'un type d'objet si plus aucune instance de cet objet ne réside en mémoire.

Là encore, différentes remarques doivent être gardées à l'esprit.

• Tout comme pour les constructeurs, un objet peut ne pas avoir de destructeur. Une fois encore, c'est le compilateur qui se chargera de la destruction statique de l'objet.
• Un objet peut posséder plusieurs destructeurs. Leur rôle commun reste identique, mais peut s'y ajouter la destruction de certaines variables internes pouvant différer d'un destructeur à l'autre. La plupart du temps, à un constructeur distinct est associé un destructeur distinct.
• En cas d'utilisation dynamique, un destructeur s'impose pour détruire le diagramme créé par le constructeur.

V-C-1-a. Principe▲

V-C-1-b. Constructeurs et Table des Méthodes Virtuelles▲

Après les méthodes virtuelles, on se demande ce que l'on a pu inventer de pire ! Rassurez-vous, rien du tout. Les méthodes dynamiques ne sont en fait que des méthodes virtuelles.
Leur particularité réside dans le fait qu'elles sont indexées. Autrement dit, chaque méthode dynamique possède un numéro unique pour l'identifier.

Il convient de les comparer aux méthodes virtuelles :

• Avantage : les méthodes dynamiques consomment moins de mémoire ;
• Inconvénient : la gestion interne des méthodes dynamiques est plus complexe, et donc plus lente.

Par conséquent, on préfèrera toujours les méthodes virtuelles, sauf si de nombreuses méthodes virtuelles doivent être déclarées, auquel cas on se reportera aux méthodes dynamiques.

Avant de pouvoir utiliser la POO, il convient de savoir déclarer un objet. Pour ce faire, on a recours au mot réservé object. Un objet étant une structure de données, il sera donc toujours déclaré à l'intérieur d'un bloc type.

L'objet le plus basique que l'on puisse déclarer est tout simplement l'objet vide, qui n'effectue rien et ne contient rien. On le déclare comme ceci :

type
  TObjetVide = object
  end;

On remarquera que la déclaration d'un objet se terminera toujours par un end;.
De plus, on adopte très souvent en Pascal une convention de notation pour les objets : leur nom commence toujours par T, comme type. Nous respecterons toujours cette convention dans ce tutoriel, et nous parlerons donc des objets TMaison ou encore TChose.

type
  TObjetVide = class
  end;

Dans la suite de ce tutoriel, nous adopterons l'utilisation de mot réservé object. Celui-ci sera à remplacer en fonction du compilateur utilisé (Delphi par exemple).

Il est parfois nécessaire de déclarer des objets qui s'utilisent mutuellement. On peut ainsi prendre l'exemple de deux objets, TParent et TEnfant, le parent ayant la nécessité de connaître la liste de ses enfants, et l'enfant la nécessité de connaître son parent.
Intervient alors le problème de la déclaration imbriquée de deux objets. Si l'on tente de les déclarer comme ceci :

type
  TParent = object
    Enfant: TEnfant;
  end;
  
  TEnfant = object
    Parent: TParent;
  end;

Le compilateur va déclencher une erreur indiquant qu'il connaît pas encore TEnfant lorsqu'il tente d'analyser la structure de TParent.
La solution au problème passe nécessairement par l'instanciation dynamique des deux objets (voir le paragraphe concerné). On va donc déclarer deux pointeurs vers les deux types considérés et seulement ensuite, on déclarera les objets eux-mêmes, ceci dans le même bloc type :

type
  { Déclaration des pointeurs }
  PParent = ^TParent;
  PEnfant = ^TEnfant;

  { Déclaration des objets utilisant les pointeurs }
  TParent = object
    Enfant: PEnfant;
  end;
  
  TEnfant = object
    Parent: PParent;
  end;

Grâce à cette méthode, plus aucune erreur n'est déclenchée, car lorsque le compilateur va analyser TParent, il aura déjà eu connaissance de l'existanceexistence de PEnfant. Ceci n'est bien évidemment possible que parce que le compilateur accepte la déclaration prématurée de pointeurs avant le type vers lequel ils pointent.

type
  { Déclarations partielles }
  TParent = class;
  TEnfant = class;

  { Déclaration des objets utilisant les classes }
  TParent = class
    Enfant: TEnfant;
  end;
  
  TEnfant = class
    Parent: TParent;
  end;

Les méthodes - procédures et fonctions - se déclarent à l'intérieur de l'objet comme on le ferait dans la partie interface d'une unité :

type
  TObjet = object
    Champs;
    ....
    procedure Methode1(Params: ParamType);
    function  Methode2(Params: ParamType): RetType;
  end;

Une fois ces méthodes déclarées, il faut écrire le code source associé. On complète leur déclaration en dehors de la déclaration de l'objet. Le nom de la méthode est alors précédé du nom de l'objet suivi d'un point. Un exemple expliquant aussi bien, voici donc ce que donnerait l'ajout d'une méthode Methode1 :

type
  TObjet = object
    procedure Methode1(Param: ParamType);
  end;
  
  
procedure TObjet.Methode1(Param: ParamType);
begin
  ...
end;

Comme il s'agit d'une déclaration de type forward, on peut éventuellement omettre les paramètres lorsque l'on complète la déclaration d'une méthode :

type
  TObjet = object
    procedure Methode1(Param: ParamType);
  end;
  
  
procedure TObjet.Methode1;
begin
  ...
end;

Ce code et le code précédent sont tous deux parfaitement identiques. On choisira donc de privilégier soit la facilité de lecture, soit la simplicité d'écriture.

Un constructeur se déclare exactement comme une autre méthode. Il n'y a pas d'ordre particulier, et on peut très bien intercaler des constructeurs au milieu des autres méthodes. Le mot réservé procedure (ou function) sera ici remplacé par le mot réservé constructor :

type
  TObjet = object
    constructor Init(Param: ParamType);
  end;
  
  
constructor TObjet.Init;
begin
  ...
end;

L'usage veut que le constructeur principal d'un objet soit appelé Init ou Create. Il n'y a aucune obligation dans ce domaine, mais on essaie la plupart du temps de suivre cette convention.

Il est possible de faire échouer un constructeur, par exemple si une opération nécessaire à l'initialisation de l'objet s'est mal déroulée.
En fonction du compilateur, soit on déclenchera une exception (Delphi), soit on fera appel à la procédure Fail :

type
  TObjet = object
    constructor Init;
   end;

constructor TObjet.Init;
begin
  ...
  { Fait échouer le constructeur }
  if ... then Fail;
end;

De même que pour les constructeurs, on se servira ici du mot réservé destructor :

type
  TObjet = object
    destructor Done;
  end;
  
  
destructor TObjet.Done;
begin
  ...
end;

Ici encore, l'usage veut que l'on appelle les destructeurs Done ou Destroy. De plus, la plupart du temps, un destructeur n'aura pas de paramètre. Toutefois, le contraire est tout à fait autorisé par le compilateur.

Si vous désirez déclarer une méthode virtuelle, alors vous devez ajouter à la déclaration de la méthode (procédure, fonction, constructeur ou destructeur) le mot réservé virtual suivi d'un point-virgule. virtualne devra pas être repris lorsque vous complèterez le code de la méthode :

type
  TObjet = object
    procedure Methode(Param: ParamType); virtual;
  end;
  
procedure Methode(Param: ParamType);
begin
  ...
end;

Les méthodes dynamiques sont également appelées méthodes virtuelles indexées. En effet, rien ne les distingue des méthodes virtuelles si ce n'est qu'elles possèdent un index, un numéro pour les identifier.
La déclaration d'une méthode dynamique varie d'un compilateur à un autre. Sur les compilateurs plus anciens, elles seront déclarées comme ceci :

type
  TObjet = object
    procedure Methode(Param: ParamType); virtual IndexUnique;
  end;
  
procedure Methode(Param: ParamType);
begin
  ...
end;

Où IndexUnique représente un entier unique permettant d'identifier la méthode virtuelle.

type
  TObjet = class
    procedure Methode(Param: ParamType); dynamic;
  end;
  
procedure TObjet.Methode(Param: ParamType);
begin
  ...
end;

La déclaration d'une méthode abstraite dépend du compilateur utilisé. Si vous utilisez un compilateur Pascal d'ancienne génération, alors, bien qu'une méthode abstraite ne doive en théorie pas posséder d'implémentation, celle-ci se déclarera comme toute autre méthode, et dans le corps de la méthode, on ajoute un appel à la procédure Abstract; :

type
  TObjet = object
    procedure MethodeAbs;
  end;
  
procedure TObjet.MethodeAbs;  
begin
  { C'est une méthode abstraite }
  Abstract;
end;

type
  TObjet = class
    { C'est une méthode abstraite }
    procedure MethodeAbs; abstract;
  end;

Dès lors qu'une méthode est appelée, le compilateur lui fournit implicitement, autrement dit de manière non visible, un paramètre supplémentaire, Self, que vous n'avez donc pas à gérer.

Le paramètre Self représente l'instance de l'objet en cours, et possède donc le même type que l'objet. Ainsi, si un objet possède un champ nommé Toto, alors les deux codes suivants seront identiques :

procedure TObjet.Methode;
begin
  Toto := 1;
end;

procedure TObjet.Methode;
begin
  Self.Toto := 1;
end;

Le paramètre Self sert de manière interne à l'objet pour garantir un appel correct des méthodes virtuelles.
Pour le programmeur, Self peut aussi servir à vérifier qu'une instance d'un même type d'objet est déjà en mémoire et, par exemple, interdire la création d'une nouvelle instance :

type
  TObjet = object
    constructor Init;
  end;

var
  Instance: TObjet;

constructor TObjet.Init;
begin
  if Instance <> Self then Fail;
  ...
end;

begin
  Instance.Init;
  ...
end.

Un objet en Pascal ne peut hériter que d'un seul ancêtre. Afin de spécifier celui-ci, on spécifie son nom entre parenthèses après le mot réservé object :

type
  TObjet = object(TAncetre)
    ...
  end;

Sitôt qu'un ancêtre est déclaré pour un objet, ce dernier peut accéder à tous les champs et méthodes de son ancêtre sans avoir à les redéclarer (en fonction de la visibilité).

type
  TAncetre = object
    Champ: Integer;
    procedure ModifChamp(Valeur: Integer); virtual;
    procedure ARedefinir;
  end;

procedure TAncetre.ModifChamp(Valeur: Integer);
begin
  Champ := Valeur;
end;

procedure TAncetre.ARedefinir;
begin
  ...
end;


type
  TDescendant = object(TAncetre)
    procedure ModifChamp(Valeur: Integer); virtual;
    procedure ARedefinir(ParamSup: Integer);
  end;

{ On surcharge la méthode virtuelle ModifChamp en la remplaçant par une autre }
procedure TDescendant.ModifChamp(Valeur: Integer);
begin
  { On accède au champ sans le redéclarer dans TDescendant }
  Champ := Valeur + 1;
end;

{ La méthode a été redéfinie avec de nouveaux paramètres }
procedure TDescendant.ARedefinir(ParamSup: Integer);
begin
  ...
end;

La plupart du temps, lorsque l'on surcharge une méthode, le but n'est pas d'écraser l'ancienne, mais de la compléter de façon à apporter de nouvelles fonctionnalités. Il est donc nécessaire de pouvoir appeler la méthode ancêtre.
Deux cas de figure sont alors à envisager.

VII-D-2-a. Ancêtre direct▲

type
  TAncetre = object
    Champ: Integer;
    procedure ModifChamp(Valeur: Integer); virtual;
  end;
  
procedure TAncetre.ModifChamp(Valeur: Integer);
begin
  Champ := Valeur;
end;


type
  TDescendant = object(TAncetre)
    Temp: Integer;
    procedure ModifChamp(Valeur: Integer); virtual;
  end;
  
procedure TDescendant.ModifChamp(Valeur: Integer);
begin
  { On effectue diverses actions }
  Inc(Valeur);
  { On appelle l'ancêtre }
  inherited ModifChamp(Valeur);
  { On peut effectuer d'autres actions }
  Temp := Champ;
end;

VII-D-2-b. Ancêtre indirect▲

type
  TPremier = object
    ...
    procedure Methode; virtual;
  end;
  
procedure TPremier.Methode;
begin
  ...
end;


type
  TSecond = object(TPremier)
    ...
    procedure Methode; virtual;
  end;

procedure TSecond.Methode;
begin
  ...
end;

  
type
  TDernier = object(TSecond)
    ...
    procedure Methode; virtual;
  end;
  
procedure TDernier.Methode;
begin
  ...
  { On appelle TPremier.Methode : TSecond.Methode est ignorée }
  TPremier.Methode;
end;

Lorsque que le constructeur d'un ancêtre est appelé avec inherited, celui-ci renvoie une valeur booléenne indiquant si la construction de l'objet s'est effectuée sans erreur.
Ainsi, si la construction a échoué dans l'ancêtre (par un appel à Fail notamment), alors il convient de faire échouer également la construction du descendant, celui-ci ne pouvant fonctionner sans le support de son ancêtre. Dès lors, il faudra aussi faire un appel à Fail.

Généralement, on adopte la syntaxe suivante :

constructor TDescendant.Init(...);
begin
  if not inherited Init(...) then Fail;
  ...
end;

S'il est possible de faire appel à inherited où on le souhaite et le nombre de fois désiré dans une méthode, les constructeurs et les destructeurs sont régis par des règles plus strictes qui ne seront pas vérifiées par le compilateur. Elles sont donc d'autant plus importantes.

• Constructeurs :
  D'une manière générale, le constructeur ancêtre devra être appelé en premier lieu, aucune autre instruction ne devant précéder cet appel.
  Cependant, il est possible d'effectuer diverses opérations en vue, par exemple, de transmettre une valeur en paramètre au constructeur ancêtre. Néanmoins, on s'abstiendra de toute modification de la valeur d'un champ avant l'appel à l'ancêtre, car cette valeur serait sujette à modification.

constructor TDescendant.Init(...);
begin
  { Première opération du constructeur : l'appel de l'ancêtre }
  if not inherited Init(...) then Fail;
  ...
end;

• Destructeur :
  De façon logique, l'appel au destructeur ancêtre devra se faire en dernier, une fois tous les champs du descendant nécessitant un traitement particulier désalloués proprement. En effet, une fois un destructeur appelé, il est impossible de prévoir la valeur d'un champ.

destructor TDescendant.Done;
begin
  ...
  { Dernière opération du destructeur : l'appel de l'ancêtre }
  inherited Done;
end;

L'instanciation statique est certainement la plus simple à mettre en oeuvre, mais aussi celle à éviter le plus possible. Elle consiste à simplement déclarer une variable du type objet comme on déclarerait n'importe quelle variable :

type
  TObjet = object
    ...
  end;

var
  MonObjet: TObjet;

Si l'objet possède un constructeur, celui-ci devra être appelé avant toute autre méthode, et de même, si l'objet possède un destructeur, il devra être appelé en dernier.

type
  TObjet = object
    ...
    constructor Init(...);
    destructor Done;
  end;

constructor TObjet.Init(...);
begin
  ...
end;

destructor TObjet.Done;
begin
  ...
end;


var
  MonObjet: TObjet;

begin
  ...
  MonObjet.Init(...);
  ...
  MonObjet.Methode;
  ...
  MonObjet.Done;
  ...
end.

L'instanciation dynamique est certainement la plus utilisée et celle permettant de stocker en mémoire le plus d'objets et d'informations. Elle suppose bien entendu une connaissance des pointeurs.

Afin de pouvoir utiliser le dynamique, il faut commencer par déclarer un pointeur vers le type objet que l'on projette d'utiliser. L'usage veut que cette déclaration se fasse conjointement avec celle de l'objet en lui-même. De même, on choisit généralement de faire figurer la déclaration du pointeur juste avant celle de l'objet.
Le nom du pointeur pourra reprendre celui de l'objet, en remplaçant le T initial par un P. Par exemple, si l'on considère l'objet TObjet, alors le pointeur vers l'objet sera nommé communément PObjet.

type
  PObjet = ^TObjet;
  TObjet = object
    ...
  end;

VII-E-2-a. Allocation▲

var
  Objet: PObjet;

begin
  New(Objet, Init(...));
  ...
end.

var
  Objet: PObjet;

begin
  Objet := New(PObjet, Init(...));
  ...
end.

var
  Objet: PObjet;

begin
  ...
  Objet^.Methode(...);
  ...
end.

var
  Objet: PObjet;

begin
  Objet := New(PObjet, Init(...));
  if Objet <> nil then
  begin
    ...
    Dispose(Objet, Done);
  end;
end.

var
  Objet: PObjet;

begin
  Objet := New(PObjet, Init(...));
  if Assigned(Objet) then
  begin
    ...
    Dispose(Objet, Done);
  end;
end.

type
  TObjet = class
    constructor Create(...);
  end;


var
  Objet: TObjet;

begin
  Objet := TObjet.Create(...);
  try
    ...
  finally
    ...
  end;
end;

VII-E-2-b. Désallocation▲

var
  Objet: PObjet;

begin
  ...
  Dispose(Objet, Done(...));
end.

var
  Objet: TObjet;

begin
  Objet := TObjet.Create(...);
  try
    ...
  finally
    TObjet.Free;
  end;
end.