Templates/fr: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: Templates/fr

New		Line
1	+	## Introduction
2	+
3	+	Les patrons sont un mécanisme simple pour résoudre l'écriture de code dupliqué et pour mettre en oeuvre une classe générale pour un type particulier dans un langage fortement typé. Il est utilisé pour les types de base (non objet) ; pour les objets, l'héritage depuis la classe de base TObject (racine de la hiérarchie de classe) est souvent employé pour construire des classes générales (par exemple TObjectList). Dans des langages avancés, les patrons sont remplacés par une implémentation native des prétendus “génériques.” L'implémentation native des génériques dans FPC 2.4.0 est encore ni complète ni utilisable dans la pratique.
4	+
5	+	Pour:
6	+
7	+	- Sûreté du typage – élimine l'ennui des conversions de type et les erreurs qu'il cause souvent.
8	+	- Meilleur maintenabilité – la classe générique est écrite une seule fois et utilisée dans toutes ses classes spécialisées.
9	+	- Meilleure réutilisation de code – Il est possible de créer un bon ensemble de classes génériques réutilisables.
10	+	- Meilleure efficacité, scalabilités – les types de classe générique peuvent être mieux ajusté à un besoin particulier. E.g., sur une machine 16-bit, une TList spécialisée avec un index de type Smallint 16-bit peutr être utilisé.
11	+
12	+	Contre:
13	+
14	+	- Plus complexe
15	+	- Un code plus gros – chaque classe spécialisée est compilée séparément et produit du code supplémentaire.
16	+
17	+	## Usage
18	+
19	+	L'exemple classique d'une classe générique de base est une liste d'articles. Free Pascal offre trois façons d'utilise les listes:
20	+
21	+	- array of – la structure classique de tableau dynamique qui peut tenir des articles d'un même type. Les articles sont adressés directement: UnTableau\[Index\]. Les fonctions SetLength et Length sont là pour manipuler la taille.
22	+	- TList – manière orienté-objet dans laquelle la classe manipule toutes les opérations de liste. L'implémentation dans la LCL conserve la compatibilité avec la VCL, où la TList contient une liste de pointeurs. Si une liste d'articles d'un type différent est souhaité, une classe complètement nouvelle doit être copiée et ré-écrite ou une conversion de type doit être utilisée à chaque endroit où un article de la liste est référencé. La conversion de type n'est pas efficace —e.g., Pointer(Byte)— et pas sûre en typage: Pointer(Int64). Un index de TListest de type entier. Si des Int64 ou des Smallint sont voulus alors la classe doit être copiée et ré-écrite.
23	+	- TCollection – est plus générique et de typage sûr mais une solution plus lourde pour le stockage d'une liste d'articles. Dans cette approche, le programmeur doit créer une classe article qui hérite de TCollectionItem et placer cette classe nouvellement créée en paramètre de constructeur de TCollection.
24	+	- génériques natifs – pas encore d'implémentation complète. Il manque le support des référence de type générique, l'héritage, les contraintes.
25	+	- templates – utilise des inclusions de code pour contourner le manque de support natif. Peut utiliser l'héritage et les références de type génériques.
26	+
27	+	Les contraintes sont données par les opérateurs et autres fonctions dans la classe générique.
28	+
29	+	Les patrons tentent de résoudre le problème en utilisant le concept des fichiers d'inclusion paramétrés. Une unité générique est écrite une seule fois, comme un patron avec l'utilisation de types génériques (non spécifié) en même temps dans les sections interface et implementation. Ainsi dans le processus de spécialisation, un patron de classe est utilisé et les paramètres généraux du patron sont remplacés par les types spécifiques pour créer une nouvelle classe spécialisée.
30	+
31	+	GenericList.inc:
32	+
33	+	``` pascal
34	+	{$IFDEF INTERFACE}
35	+	// TGList<T> = class
36	+	TGList = class
37	+	Items: array of T;
38	+	procedure Add(Item: T);
39	+	end;
40	+	{$UNDEF INTERFACE}
41	+	{$ENDIF}
42	+
43	+	{$IFDEF IMPLEMENTATION}
44	+	procedure TGList.Add(Item: T);
45	+	begin
46	+	SetLength(Items, Length(Items) + 1);
47	+	Items[Length(Items) - 1] := Item;
48	+	end;
49	+	{$UNDEF IMPLEMENTATION}
50	+	{$ENDIF}
51	+	```
52	+
53	+	Dans le processus de spécialisation, les fichiers patron créés auparavant sont inclus dans la nouvelle unité.
54	+
55	+	ListInteger.pas:
56	+
57	+	``` pascal
58	+	unit ListInteger;
59	+
60	+	interface
61	+
62	+	uses
63	+	Classes;
64	+
65	+	type
66	+	T = Integer; // T is specified to some exact type
67	+	{$DEFINE INTERFACE}
68	+	{$INCLUDE 'GenericList.inc'}
69	+
70	+	type
71	+	// TListInteger<Integer> = class
72	+	TListInteger = class(TGList)
73	+	// Additional fields and methods can be added here
74	+	end;
75	+
76	+	implementation
77	+
78	+	{$DEFINE IMPLEMENTATION}
79	+	{$INCLUDE 'GenericList.inc'}
80	+
81	+	end.
82	+	```
83	+
84	+	Au final, nous avons une nouvelle unité spécialisée appelée ListInteger que nous pouvons utiliser dans du code.
85	+
86	+	``` pascal
87	+	program GenericTest;
88	+	{$mode ObjFPC}
89	+	uses
90	+	ListInteger;
91	+	var
92	+	List: TListInteger;
93	+	begin
94	+	try
95	+	List := TListInteger.Create;
96	+	List.Add(1);
97	+	List.Add(2);
98	+	List.Add(3);
99	+	finally
100	+	List.Free;
101	+	end;
102	+	end.
103	+	```
104	+
105	+	### Héritage
106	+
107	+	Les classes génériques pourraient hériter les unes des autres comme le font les classes non génériques. L'implémentation est un peu plus difficile étant donné qu'un seul type spécialisé d'un classe particulière peut être définie par unité. Pour être capable de spécifier une classe génériques qui hérite d'une autre classe générique, certaines conventions de nommage devrait être observées.
108	+
109	+	Supposons que nous voulons créer une liste perfectionnée TAdvancedList qui a un champ Capacity en plus.
110	+
111	+	La définition de la classe de base:
112	+
113	+	GenericList.inc:
114	+
115	+	``` pascal
116	+	{$IFDEF INTERFACE}
117	+	// TGList<TListIndex, TListItem> = class
118	+	TGList = class
119	+	Items: array[TListIndex] of TListItem;
120	+	procedure Add(Item: TListItem);
121	+	end;
122	+	{$UNDEF INTERFACE}
123	+	{$ENDIF}
124	+
125	+	{$IFDEF IMPLEMENTATION}
126	+	procedure TGList.Add(Item: TListItem);
127	+	begin
128	+	SetLength(Items, Length(Items) + 1);
129	+	Items[Length(Items) - 1] := Item;
130	+	end;
131	+	{$UNDEF IMPLEMENTATION}
132	+	{$ENDIF}
133	+	```
134	+
135	+	Définition pour la classe générique améliorée:
136	+
137	+	GenericAdvancedList.inc:
138	+
139	+	``` pascal
140	+	{$IFDEF INTERFACE}
141	+	TListIndex = TAdvancedListIndex;
142	+	TListItem = TAdvancedListItem;
143	+	{$DEFINE INTERFACE}
144	+	{$INCLUDE 'GenericList.inc'}
145	+	// TGAdvancedList<TAdvancedListIndex, TAdvancedListItem> = class(TGList)
146	+	TGAdvancedList = class
147	+	Capacity: TAdvancedListIndex;
148	+	end;
149	+	{$UNDEF INTERFACE}
150	+	{$ENDIF}
151	+
152	+	{$IFDEF IMPLEMENTATION}
153	+	{$INCLUDE 'GenericList.inc'}
154	+	{$UNDEF IMPLEMENTATION}
155	+	{$ENDIF}
156	+	```
157	+
158	+	Maintenant, un exemple de spécialisation: AdvancedListInteger.pas:
159	+
160	+	``` pascal
161	+	unit AdvancedListInteger;
162	+
163	+	interface
164	+
165	+	uses
166	+	Classes;
167	+
168	+	type
169	+	TAdvancedListIndex = Integer; // spécifié dans un type exact
170	+	TAdvancedListItem = Integer; // spécifié dans un type exact
171	+	{$DEFINE INTERFACE}
172	+	{$INCLUDE 'GenericAdvancedList.inc'}
173	+
174	+	type
175	+	// TAdvancedListInteger<Integer, Integer> = class
176	+	TAdvancedListInteger = class(TGAdvancedList)
177	+	// Des champs et méthodes supplémentaires peuvent être ajoutés ici.
178	+	end;
179	+
180	+	implementation
181	+
182	+	{$DEFINE IMPLEMENTATION}
183	+	{$INCLUDE 'GenericAdvancedList.inc'}
184	+
185	+	end.
186	+	```
187	+
188	+	Maintenant, nous avons une classe spécialisée depuis la classe générique héritée d'une autre classe générique.
189	+
190	+	### Contraintes
191	+
192	+	Il est bon d'avoir des classes qui par exemple fonctionnent comme des conteneurs d'autres types. Une classe conteneur n'a pas besoin de connaître quoi que ce soit de la classe contenue. Mais certaines classes pourraient bénéficier de la connaissance de ce qui peut être fait avec la classe contenue. Dans l'implémentation natives des génériques, il y a la possibilité de restreindre le groupe des types utilisables comme paramètres de la classe générique. Dans les patrons, il n'y a pas une telle caractéristique mais les contraintes sont simplement réalisée par l'usage de type génériques dans la classe générique. Si le type générique est utilisé pour l'addition ou la soustraction, alors les seuls types qui supportent ces opérations sont supportés. Les chaînes de caractères peuvent être concaténées en employant l'opérateur d'addition aussi. Mais si la multiplication est employée alors les seuls types numériques sont permis. Si un type générique est utilisé comme un index de tableau alors seuls les types ordinaux peuvent être utilisés. Si la méthode Free est utilisée sur le type générique alors la contrainte inclut toutes les classes. Donc dans les patrons, les opérations réalisées sur le type générique limite l'ensemble des des types utilisables pour la spécialisation.
193	+
194	+	Groupes contraints théoriques:
195	+
196	+	- types ordinaux
197	+	- types flottants
198	+	- enregistrements
199	+	- tableaux
200	+	- ensembles
201	+	- interfaces
202	+	- procédure, fonction, constructeur
203	+	- classes et tous les descendants.
204	+
205	+	## Classes génériques
206	+
207	+	Il y a plusieurs classes qui gagneraient à être génériques:
208	+
209	+	- TList - liste d'articles, Add, Delete, Insert, Move, Exchange, Clear, Sort,
210	+	- TDictionary - liste de paires clé et valeurs,
211	+	- TPair - Clé et valeur pour utiliser dans TDictionary
212	+	- TStack - Structure LIFO, Push et Pop
213	+	- TQueue - Structure FIFO, Enqueue et Dequeue
214	+	- TRange ou TInterval - structure à deux valeurs, Distance
215	+	- TSet - ensemble d'articles, Add, Remove, Intersection, Complement, Union, Product
216	+	- TStream - divisé en TInputStream et TOutputStream
217	+	- TTree - Structure hiérarchique de noeuds
218	+	- TMatrix - Liste multidimensionnelle
219	+	- TBitmap - TMatrix étendue avec des méthodes orientées vers le graphique
220	+	- TGraph
221	+	- TPoint - pourrait être 1D, 2D, 3D or multidimensionnel
222	+	- TVector
223	+	- TComplexNumber
224	+
225	+	Il y a quelques types spécialisés qui peuvent remplacer les types non génériques:
226	+
227	+	\| classe générique spécialisée \| Type de donnée similaire \|
228	+	\|----------------------------------------\|--------------------------\|
229	+	\| TList\<Char\> \| string \|
230	+	\| TList\<WideChar\> \| WideString \|
231	+	\| TList\<Byte\> \| array of Byte \|
232	+	\| TList\<string\> \| Classes.TStrings \|
233	+	\| TList\<Pointer\> \| Classes.TList \|
234	+	\| TList\<Boolean\> \| Classes.TBits \|
235	+	\| TList\<TObject\> \| Contnrs.TObjectList \|
236	+	\| TList\<TComponent\> \| Contnrs.TComponentList \|
237	+	\| TList\<TClass\> \| Contnrs.TClassList \|
238	+	\| TStack\<Pointer\> \| Contnrs.TStack \|
239	+	\| TStack\<TObject\> \| Contnrs.TObjectStack \|
240	+	\| TQueue\<Pointer\> \| Contnrs.TQueue \|
241	+	\| TQueue\<TObject\> \| Contnrs.TObjectQueue \|
242	+	\| TStream\<Byte\> \| Classes.TMemoryStream \|
243	+	\| TDictionary\<TPair\<string, string\>\> \| Classes.TStringList \|
244	+	\| TList\<TMethod\> \| LCLProc.TMethodList \|
245	+	\| TTree\<TTreeNode\> \| ComCtrls.TTreeView \|
246	+	\| TPoint\<Integer\> \| Classes.TPoint \|
247	+	\| TPoint\<SmallInt\> \| Classes.TSmallPoint \|
248	+	\| TRectangle\<Integer\> \| Classes.TRect \|
249	+
250	+	## Bibliothèques génériques existantes
251	+
252	+	Tout programmeur peut construire ses propres bibliothèques de classes génériques.
253	+
254	+	Quelques classes prêtes à l'emploi:
255	+
256	+	- TemplateGenerics - Paquet Lazarus de quelques classes génériques expérimentales. En plus du type paramétré pour les valeurs de liste, il offre aussi l'index en type paramétré.
257	+
258	+	Le dernier paquet peut être téléchargé depuis le référentiel svn en utilisant un client svn.
259	+
260	+	svn co http://svn.zdechov.net/svn/PascalClassLibrary/Generics/TemplateGenerics/ TemplateGenerics
261	+
262	+	## Voir aussi
263	+
264	+	- [[Generics/fr\|Génériques]]
265	+
266	+	## Liens externes
267	+
268	+	- [Object Pascal (Delphi) Templates](http://www.dummzeuch.de/delphi/object_pascal_templates/english.html)
269	+	- [Templates in Object Pascal](http://edn.embarcadero.com/article/27603)
270	+	- [Template (programming)](http://en.wikipedia.org/wiki/Template_%28programming%29) - general description and priciples
271	+	- [Generics with Delphi 2009 Win32](http://sjrd.developpez.com/delphi/tutoriel/generics/)
272	+
273	+	---
274	+	From the Free Pascal wiki, page "Templates/fr", as it stood on 2023-02-18 after a change by Kai Burghardt, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history