Difference between revisions of "Generics/fr"
m (→Unité fgl) |
|||
(8 intermediate revisions by 2 users not shown) | |||
Line 7: | Line 7: | ||
==Unité fgl== | ==Unité fgl== | ||
− | La façon la plus simple de commencer avec les génériques est | + | La façon la plus simple de commencer avec les génériques est [http://freepascal.org/docs-html/current/rtl/fgl/index.html l'unité fgl] qui est le prototype d'un système base de classes géneriques. Jusqu'ici, il contient quelques classes basiques: |
* TFPGList | * TFPGList | ||
* TFPGObjectList | * TFPGObjectList | ||
Line 14: | Line 14: | ||
* TFPGMapInterfacedObjectData | * TFPGMapInterfacedObjectData | ||
− | === | + | === Commençons === |
− | Le simple exemple suivant montre | + | Le simple exemple suivant montre comment stocker de multiples instances d'une classe définie par l'utilisateur dans une liste : |
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
uses fgl; | uses fgl; | ||
Line 41: | Line 41: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | == | + | == Classes génériques personnalisées == |
+ | Si les génériques définies dans l'unité fgl ne vous suffisent pas, vous pour avoir besoin 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 [[Keyword/fr|mot-clé]] '''generic''' avant le nom de la classe dans sa déclaration : | |
− | + | <syntaxhighlight lang="pascal"> | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | Une classe générique est définie en utilisant le [[ | ||
− | <syntaxhighlight> | ||
type | type | ||
generic TList<T> = class | generic TList<T> = class | ||
Line 112: | Line 54: | ||
Exemple d'implémentation de classe : | Exemple d'implémentation de classe : | ||
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
implementation | implementation | ||
Line 123: | Line 65: | ||
Une classe générique peut être spécialisée pour un type particulier en utilisant le mot-clé '''specialize'''. | Une classe générique peut être spécialisée pour un type particulier en utilisant le mot-clé '''specialize'''. | ||
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
Type | Type | ||
TIntegerList = specialize TList<Integer>; | TIntegerList = specialize TList<Integer>; | ||
Line 132: | Line 74: | ||
== Détails techniques == | == Détails techniques == | ||
− | + | # Le compilateur analyse une générique, mais au lieu de produire du code, il enregistre tous les jetons ("token") dans un tampon de jetons à l'intérieur du fichier PPU. | |
− | + | # 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é. | 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. | 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. | ||
+ | |||
+ | == Exemple == | ||
+ | {{:How to use generics/fr}} | ||
==Voir aussi== | ==Voir aussi== |
Latest revision as of 15:38, 1 July 2019
│
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 comment 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 vous suffisent pas, vous pour avoir besoin 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
- Le compilateur analyse une générique, mais au lieu de produire du code, il enregistre tous les jetons ("token") dans un tampon de jetons à l'intérieur du fichier PPU.
- 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.
Exemple
Un exemple de comment utiliser des génériques pour écrire une function gmax()
qui prend la maximum de deux variables non encore typées.
Remarquez que les fonctions sont nommées dans leur espace (namespaced) par leur nom de classe. Un inconvénient peut être que les génériques ne peuvent surchargées.
Notez encore que l'opérateur devra être défini pour le type précisé lors de la spécialisation.
program UseGenerics;
{$mode objfpc}{$H+}
type
generic TFakeClass<_GT> = class
class function gmax(a,b: _GT):_GT;
end;
TFakeClassInt = specialize TFakeClass<integer>;
TFakeClassDouble = specialize TFakeClass<double>;
class function TFakeClass.gmax(a,b: _GT):_GT;
begin
if a > b then
result := a
else
result := b;
end;
begin
// show max of two integers
writeln( 'Integer GMax:', TFakeClassInt.gmax( 23, 56 ) );
// show max of two doubles
writeln( 'Double GMax:', TFakeClassDouble.gmax( 23.89, 56.5) );
readln();
end.
Voir aussi
- Patrons
- Generics proposals (non traduit, intérêt historique uniquement)
- Structures de données, Conteneurs, Collections
External links