Références de classes

Remonter à Classes et objets - Index

Parfois des opérations sont effectuées sur la classe même et pas sur une instance de la classe (c'est-à-dire sur des objets). Cela se produit, par exemple, quand vous appelez une méthode constructeur utilisant une référence de classe. Vous pouvez toujours désigner une classe spécifique par son nom, mais dans certains cas, il est nécessaire de déclarer des variables ou des paramètres qui prennent des classes pour valeur. Il faut alors utiliser des types référence de classe.

Cette rubrique couvre les sujets suivants :

• Types références de classe
• Opérateurs de classes

Types de référence de classe

Un type référence de classe, appelé parfois une métaclasse, est désigné par une construction de la forme :

class of type

où type est un type classe. L'identificateur type même désigne une valeur dont le type est class of type. Si type1 est un ancêtre de type2, alors class of type2 est compatible pour l'assignation avec class of type1. Donc

 type TClass = class of TObject;
 var AnyObj: TClass;

déclare une variable appelée AnyObj qui peut contenir une référence sur toute classe. La définition d'un type référence de classe ne peut se faire directement dans une déclaration de variable ou une liste de paramètres. Vous pouvez affecter la valeur nil à une variable de tout type référence de classe.

Un exemple d'utilisation de type référence de classe est fourni par la déclaration du constructeur de System.Classes.TCollection (dans l'unité System.Classes) :

 
 type TCollectionItemClass = class of TCollectionItem;
      ...
 TCollection = class(TPersistent)
      ...
   constructor Create(ItemClass: TCollectionItemClass);

Cette déclaration indique que pour créer un objet instance de TCollection, il faut transmettre au constructeur le nom d'une classe descendant de TCollectionItem.

Les types référence de classe sont utiles quand vous voulez désigner une méthode de classe ou un constructeur virtuel pour une classe ou un objet dont le type réel est inconnu à la compilation.

Constructeurs et références de classe

Il est possible d'appeler un constructeur en utilisant une variable de type référence de classe. Cela permet la construction d'objets dont le type est inconnu à la compilation. Par exemple,

 
 type TControlClass = class of TControl;
 
 function CreateControl(ControlClass: TControlClass;
     const ControlName: string; X, Y, W, H: Integer): TControl;
   begin
     Result := ControlClass.Create(MainForm);
     with Result do
       begin
         Parent := MainForm;
         Name := ControlName;
         SetBounds(X, Y, W, H);
         Visible := True;
       end;
   end;

La fonction CreateControlnécessite un paramètre référence de classe pour lui indiquer le type de contrôle à créer. Elle utilise ce paramètre pour appeler le constructeur de la classe. Comme les identificateurs de type classe désignent des valeurs référence de classe, un appel à CreateControl peut spécifier l'identificateur de la classe pour en créer une instance. Par exemple,

 CreateControl(TEdit, 'Edit1', 10, 10, 100, 20);

Les constructeurs appelés en utilisant des références de classe sont généralement virtuels. L'implémentation du constructeur qui est activée par l'appel dépend du type à l'exécution de la référence de classe.

Opérateurs de classe

Les méthodes de classe portent sur les références de classe. Chaque classe hérite de deux méthodes de classe de TObject, appelées ClassType et ClassParent. Ces méthodes renvoient, respectivement, une référence à la classe d'un objet et une référence à une classe ancêtre immédiate d'un objet. Ces deux méthodes renvoient une valeur de type TClass (où TClass = class of TObject), qui peut être transtypée dans un type plus spécifique. Chaque classe hérite également de la méthode InheritsFrom qui teste si l'objet pour lequel elle est appelée hérite d'une classe spécifiée. Ces méthodes sont utilisées par les opérateurs is et as, il est donc rarement nécessaire de les appeler directement.

Opérateur is

L'opérateur is, qui effectue une vérification de type dynamique, est utilisé pour vérifier quelle est effectivement la classe d'un objet à l'exécution. L'expression

objet is classe

renvoie True si objet est une instance de la classe désignée par classe ou de l'un de ses descendants, et False sinon. (Si objet a la valeur nil, le résultat est False.) Si le type déclaré pour objet n'est pas relié à classe (c'est-à-dire si les types sont distincts ou si l'un n'est pas l'ancêtre de l'autre), il y a erreur de compilation. Par exemple,

 if ActiveControl is TEdit then TEdit(ActiveControl).SelectAll;

Cette instruction transtype la variable ActiveControl en TEdit vérifie d'abord que l'objet qu'elle référence est bien une instance de TEdit ou de l'un de ses descendants.

Opérateur as

L'opérateur as effectue des transtypages avec vérification. L'expression

object as class

renvoie une référence au même objet que objet, mais avec le type spécifié par classe. A l'exécution, objet doit être une instance de la classe désignée par classe ou de l'un de ses descendants ou avoir la valeur nil ; sinon une exception est déclenchée. Si le type déclaré pour objet n'est pas relié à classe (c'est-à-dire si les types sont distincts ou si l'un n'est pas l'ancêtre de l'autre), il y a erreur de compilation. Par exemple,

 
 with Sender as TButton do
  begin
   Caption := '&Ok';
   OnClick := OkClick;
  end;

Les règles de priorité des opérateurs obligent souvent à placer entre parenthèses un transtypage as. Par exemple,

 (Sender as TButton).Caption := '&Ok';

Voir aussi

• Classes et objets
• Champs
• Méthodes
• Propriétés
• Déclarations de types imbriqués
• Exceptions
• Surcharge d'opérateurs (Delphi)
• Assistances de classes et d'enregistrements (Delphi)

Exemples de code

• ClassParent (Delphi)