L'instruction Interface de PureBasic, permet de regrouper sous un même Nom (<Nom1> dans l'encadré) différentes procédures.

Ex :

Il suffit de déclarer un élément de type Mon_Objet pour accéder aux procédures qu'elle détient.
La déclaration se fait de la même manière que pour une Structure :

Nous pouvons alors utiliser les fonctions de Objet directement comme suite:

Lancer une procedure grâce à l'instruction Interface se fait par une notation fort pratique et agréable.
En écrivant " Objet\Procedure1(10, 20) ", on lance la Procedure1() de l'élément Objet.
Cette notation est typique de la Programmation Orienté Objet.

Initialisation :
Comme toute déclaration d'une variable typée, il s'en suit normalement l'initialisation de la variable.
Il en est de même lorsque l'on déclare un élément dont le type provient d'une Interface.

Contre toute attente, il ne suffit pas de donner le nom d'une procédure à l'intérieur du bloc Interface/EndInterface pour que cela fasse référence à l'implémentation de cette procédure, c'est à dire que l'on référence le bloc Procédure/EndProcedure de la procédure voulue.

En réalité vous pouvez renommer les procédures dans un bloc Interface/EndInterface, c'est à dire donner les noms que vous voulez aux procédures que vous allez utiliser.

Comment relier alors ce nouveau nom à la vraie procédure ?

Comme pour la surcharge de méthode, la solution se trouve dans les adresses de fonctions.
Il faut voir en effet les noms contenus dans le bloc Interface/EndInterface, comme des pointeurs de fonctions auxquels on attribut les adresses des fonctions que l'on désire y mettre.

Cependant, pour initialiser les pointeurs de fonctions d'un élément typé par une Interface, il faut procéder différemment qu'avec un élément typé par une Structure.
Il n'est en effet pas possible d'initialiser individuellement chacun des champs définis par une Interface, car rappelez-vous que d'écrire Objet\Procedure1() revient à lancer une procédure.

L'initialisation se réalise indirectement en donnant à l'élément l'adresse d'une variable composée des pointeurs de fonctions préalablement initialisée.

Une telle variable est appelée table des méthods.

Ex : Si l'on reprend l'Interface Mon_Objet.
Considérons la Structure suivante de description des pointeurs de fonctions :

et la variable initialisée associée:

où Ma_Procedure1() et Ma_Procedure2() sont les implémentations des procédures que l'on veut utiliser.

Alors, l'initialisation de l'élément Objet de type Mon_Objet se fera comme suite :

Ainsi, en écrivant

on lance la fonction Procedure2() de l'élément Objet, c'est à dire Ma_Procedure2().

Lorsque l'on déclare un élément typé par une interface, il est obligatoire de l'initialiser avant de se servir des procédures de l'élément. Il est donc vivement conseillé d'initialiser l'élément dès sa déclaration.

La composition de la Structure décrivant les pointeurs de fonctions, doit être le reflet exact de la composition de l'Interface. C'est à dire qu'elle doit comporter le même nombre de champs et respecter l'ordre pour que l'attribution entre les noms et les adresses de chaque fonction soit celle attendue. C'est seulement à ces conditions que l'élément sera correctement initialisé.

Pour résumer, utiliser une Interface c'est disposer:

• d'une Interface décrivant les procédures que l'on veut utiliser,
• d'une Structure décrivant les pointeurs d'adresses des fonctions,
• d'une table des méthodes: variable initialisée issue de cette structure.

C'est aussi:

• bénéficier d'une notation orientée objet,
• pouvoir renommer facilement les procédures.

Sommaire

Page suivante

  [1-2-3-4-5-6-7-8-9]