Difference between revisions of "Generics/fr"

From Lazarus wiki
m (Exemples)
(Classes génériques personnalisées)
Line 42: Line 42:
  
 
== Classes génériques personnalisées ==
 
== Classes génériques personnalisées ==
 +
Si les génériques définies dans l'unité <code>fgl</code> ne conviennent pas à vos besoins, vous pouveez avoir besoin de créer vos propres classes génériques à partir de rien en utilisant les primitives sous-jacentes du langage.
  
 
Une classe générique est définie en utilisant le mot-clé '''generic''' avant le nom de la classe dans la déclaration de celle-ci:
 
Une classe générique est définie en utilisant le mot-clé '''generic''' avant le nom de la classe dans la déclaration de celle-ci:

Revision as of 10:54, 16 October 2017

English (en) français (fr) 한국어 (ko) polski (pl) русский (ru)

Introduction

Les types génériques de la Free Generics Library ou FGL sont une implémentation native des patrons de classe. Les génériques sont parfois appelés types paramétrés. FPC supporte officiellement les génériques depuis la version 2.2.

Unité fgl

La façon la plus simple de commencer avec les génériques est l'unité fgl qui est le prototype d'un système base de classes géneriques. Jusqu'ici, il contient quelques classes basiques:

  • TFPGList
  • TFPGObjectList
  • TFPGInterfacedObjectList
  • TFPGMap
  • TFPGMapInterfacedObjectData

Commençons

Le simple exemple suivant montre comme stocker de multiples instances d'une classe définie par l'utilisateur dans une liste :

uses fgl;

type
   TMyClass = class(TObject)
      fld1 : string;
   end;

   TMyList = specialize TFPGObjectList<TMyClass>;

var
   list : TMyList;
   c : TMyClass;

begin
   // create the list and add an element
   list := TMyList.Create;
   c := TMyClass.Create;
   c.fld1 := 'c1';
   list.Add(c);
   // retrieve an element from the list
   c := list[0];

Classes génériques personnalisées

Si les génériques définies dans l'unité fgl ne conviennent pas à vos besoins, vous pouveez avoir besoin de créer vos propres classes génériques à partir de rien en utilisant les primitives sous-jacentes du langage.

Une classe générique est définie en utilisant le mot-clé generic avant le nom de la classe dans la déclaration de celle-ci:

type
  generic TList<T> = class
    Items: array of T;
    procedure Add(Value: T);
  end;

Exemple d'implémentation d'une classe générique:

implementation

procedure TList.Add(Value: T);
begin
  SetLength(Items, Length(Items) + 1);
  Items[Length(Items) - 1] := Value;
end;

Une classe générique peut être simplement spécialisée pour un type particulier en utilisant le mot-clé specialize.

Type  
  TIntegerList = specialize TList<Integer>;
  TPointerList = specialize TList<Pointer>;
  TStringList = specialize TList<string>;

Classes générique personnalisée

Si les génériques définies dans l'unité fgl ne vous suffisent pas, vous pour avoir besion de définir vos propres classes génériques à partir de rien en utilisant les primtives sous-jacentes du langage.

Une classe générique est définie en utilisant le mot-clé generic avant le nom de la classe dans sa déclaration :

type
  generic TList<T> = class
    Items: array of T;
    procedure Add(Value: T);
  end;

Exemple d'implémentation de classe :

implementation

procedure TList.Add(Value: T);
begin
  SetLength(Items, Length(Items) + 1);
  Items[Length(Items) - 1] := Value;
end;

Une classe générique peut être spécialisée pour un type particulier en utilisant le mot-clé specialize.

Type  
  TIntegerList = specialize TList<Integer>;
  TPointerList = specialize TList<Pointer>;
  TStringList = specialize TList<string>;

Détails techniques

1. Le compilateur analyse une générique, mais au lieu de produire du code, il enregistre tous les jetons ("token") dans un tampon de jeton à l'intérieur du fichier PPU.

2. Le compilateur analyse une spécialisation ; pour cela, il charge le tampon de tokens du fichier PPU et l'analyse à nouveau. Il remplace les paramètres génériques (dans la plupart des exemples "T") par le type particulier spécifié (par exemple LongInt, TObject). Le code apparaît fondamentalement comme si la même classe avait été écrite comme la classe générique mais en remplaçant le type (formel) T par le type (effectif) spécifié.

Donc en théorie, il n'y aurait pas de différence de vitesse d'exécution entre une classe "normale" et une générique.

Voir aussi

External links