Discussion :

[e-ric]

Rebelote !

Plus besoin de modulo ni de div, la version optimisée de numéral est une approche mixte de numéral et d'itératif. Code de la démo

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
unit CombinationFrms;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Math;
 
type
  TCombinationFrm = class(TForm)
    Memo: TMemo;
    btnAlgoRecurs: TButton;
    Edit: TEdit;
    btnAlgoIteratif: TButton;
    btnAlgoNumeral: TButton;
    ckxResultInFile: TCheckBox;
    procedure btnAlgoRecursClick(Sender: TObject);
    procedure btnAlgoIteratifClick(Sender: TObject);
    procedure btnAlgoNumeralClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    function GetBuffSize(CharsLen: integer; LineSepLen: Integer): Integer;
    procedure SafeCombinationRecurs(Tab: String);
    procedure SafeCombinationIterat(const Tab: String);
    procedure SafeCombinationNumeral(Tab: String; CombSize: Integer);
    procedure SafeCombinationNumeralOpt(Tab: String; CombSize: Integer);
  end;
 
var
  CombinationFrm: TCombinationFrm;
 
implementation
 
{$R *.dfm}
 
function _Power(Base, Exponent: Integer): Integer;
var
  i: Integer;
begin
  Result := 1;
  for I := 1 to Exponent do
    Result := Result * Base;
End;
 
function TCombinationFrm.GetBuffSize(CharsLen: integer; LineSepLen: Integer): Integer;
begin
  Result := (CharsLen + LineSepLen) * _Power(CharsLen, CharsLen);
  if Result > 16777216 then
    raise Exception.Create('Nombre de caractère trop élevé pour la mémoire !');
End;
 
procedure TCombinationFrm.SafeCombinationRecurs(Tab: String);
var
  Size: Integer;
 
  procedure Combination(Level: Integer; Combin: string);
  var
    i: Integer;
  begin
    if Level = 0 then
    begin
      Memo.Lines.Add(Combin);
    end
    else
    begin
      for i := 1 to Size do
        Combination(Level-1, Combin+Tab[i]);
    end;
  End;
 
begin
  Memo.Clear;
  Size := Length(Tab);
  if Size < 1  then
    exit;
  Combination(Size, '');
End;
 
procedure TCombinationFrm.btnAlgoRecursClick(Sender: TObject);
var
  d: TDateTime;
begin
  d := Now;
  SafeCombinationRecurs(Edit.Text);
  ShowMessage('Durée = ' + FormatDateTime('hh:nn:ss:zzz', Now - d));
End;
 
procedure TCombinationFrm.SafeCombinationIterat(const Tab: String);
var
  Levels: array of PChar;
  Size, I: Integer;
  Combin: String;
 
  procedure WriteCombination;
  var
    I : Integer;
  begin
    for I := 1 to Size do
      Combin[i] := Levels[Size-I]^;
    Memo.Lines.Add(Combin);
  End;
 
  function NextCombination: Boolean;
  var
    I: Integer;
  begin
    Result := True;
    I := 0;
    while True do
    begin
      if (Levels[i]+1)^ = #0 then
      begin
        Levels[i] := @Tab[1];
        Inc(I);
        if (I >= Size) then
        begin
          Result := False;
          exit;
        end;
      end
      else
      begin
        Inc(Levels[i]);
        exit;
      end;
    end;
  End;
 
begin
  Memo.Clear;
  Size := Length(Tab);
  SetLength(Levels, Size);
  SetLength(Combin, Size);
  for I := 0 to Size-1 do
    Levels[i] := @Tab[1];
  repeat
    WriteCombination;
  until not NextCombination;
End;
 
procedure TCombinationFrm.btnAlgoIteratifClick(Sender: TObject);
var
  d: TDateTime;
begin
  d := Now;
  SafeCombinationIterat(Edit.Text);
  ShowMessage('Durée = ' + FormatDateTime('hh:nn:ss:zzz', Now - d));
End;
 
procedure TCombinationFrm.SafeCombinationNumeral(Tab: String; CombSize: Integer);
var
  I, MaxValue, Value: Int64;
  TabSize, J : Integer;
  S: TStream;
  Combin: String;
 
const
  CombinatFileName = 'C:\Temp\Combinat1.txt';
 
begin
  if not ckxResultInFile.Checked then
    S := TMemoryStream.Create
  else if FileExists(CombinatFileName) then
    S := TFileStream.Create(CombinatFileName, fmOpenWrite)
  else
    S := TFileStream.Create(CombinatFileName, fmCreate);
  try
    TabSize := Length(Tab);
    MaxValue := _Power(TabSize, CombSize);
    S.Size := MaxValue * (CombSize + 2);
    S.Seek(0, soBeginning);
    SetLength(Combin, CombSize+2);
    Combin[CombSize+1] := #13;
    Combin[CombSize+2] := #10;
    I := 0;
    while I < MaxValue do
    begin
      Value := I;
      for J := CombSize downto 1 do
      begin
        Combin[J] := Tab[Value mod TabSize + 1];
        Value := Value div TabSize;
      end;
      S.Write(Combin[1], CombSize+2);
      Inc(I);
    end;
  finally
    S.Free;
  end;
End;
 
procedure TCombinationFrm.SafeCombinationNumeralOpt(Tab: String; CombSize: Integer);
var
  I, MaxValue: Integer;
  TabSize: Integer;
  S: TStream;
  Combin: String;
  pc, pcf: PChar;
  first, last: Char;
  CombSize2: Integer;
 
const
  CombinatFileName = 'C:\Temp\Combinat2.txt';
 
begin
  if not ckxResultInFile.Checked then
    S := TMemoryStream.Create
  else if FileExists(CombinatFileName) then
    S := TFileStream.Create(CombinatFileName, fmOpenWrite)
  else
    S := TFileStream.Create(CombinatFileName, fmCreate);
  try
    TabSize := Length(Tab);
    MaxValue := _Power(TabSize, CombSize);
    CombSize2 := CombSize + 2;
    S.Size := MaxValue * CombSize2;
    S.Seek(0, soBeginning);
    Combin := StringOfChar(Tab[1], CombSize)+#13#10;
    pcf := @Combin[1];
    first := Tab[1];
    last := Tab[TabSize];
    for I := 0 to MaxValue-1 do
    begin
      S.Write(Combin[1], CombSize2);
      pc := @Combin[CombSize];
      while pc >= pcf do
      begin
        if pc^ = last then
        begin
          pc^ := first;
          Dec(pc);
        end
        else
        begin
          Inc(pc^);
          break;
        end;
      end;
    end;
  finally
    S.Free;
  end;
End;
 
procedure TCombinationFrm.btnAlgoNumeralClick(Sender: TObject);
var
  d: TDateTime;
begin
  if (Edit.Text = '') or (Edit.SelLength = 0) then
    exit;
  d := Now;
  SafeCombinationNumeral(Edit.Text, Edit.SelLength);
  ShowMessage('Durée = ' + FormatDateTime('hh:nn:ss:zzz', Now - d));
  d := Now;
  SafeCombinationNumeralOpt(Edit.Text, Edit.SelLength);
  ShowMessage('Durée = ' + FormatDateTime('hh:nn:ss:zzz', Now - d));
End;
 
END.

le dfm :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
object CombinationFrm: TCombinationFrm
  Left = 648
  Top = 307
  Width = 292
  Height = 514
  Caption = 'Combinaisons'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object Memo: TMemo
    Left = 8
    Top = 40
    Width = 265
    Height = 377
    TabOrder = 0
  end
  object btnAlgoRecurs: TButton
    Left = 8
    Top = 424
    Width = 60
    Height = 25
    Caption = 'Récursif'
    TabOrder = 1
    OnClick = btnAlgoRecursClick
  end
  object Edit: TEdit
    Left = 8
    Top = 8
    Width = 265
    Height = 21
    HideSelection = False
    TabOrder = 2
    Text = 'ABCDEFG'
  end
  object btnAlgoIteratif: TButton
    Left = 80
    Top = 424
    Width = 60
    Height = 25
    Caption = 'Itératif'
    TabOrder = 3
    OnClick = btnAlgoIteratifClick
  end
  object btnAlgoNumeral: TButton
    Left = 149
    Top = 452
    Width = 60
    Height = 25
    Caption = 'Numéral'
    TabOrder = 4
    OnClick = btnAlgoNumeralClick
  end
  object ckxResultInFile: TCheckBox
    Left = 12
    Top = 456
    Width = 133
    Height = 17
    Caption = 'Résultats en fichier'
    Checked = True
    State = cbChecked
    TabOrder = 5
  end
end

Sur ma machine de bureau, en flux mémoire pour l'ensemble ABCDEFG, j'obtiens 120 ms. Cool non !

cdlt

[ShaiLeTroll]

ABCDEFG en 120 ms mais pour quel taille d'arrangement, car sur ma machine avec mon algo, le 7 c'est 45ms, et le 8 c'est 215ms, donc je ne comprend pas l'avantage, à part la facilité de manipulation en fichier, sinon avec ton algo sur ma machine c'est 20 pour 7, et 200 pour 8, joli ! Je vois que tu as repris mon fonctionnement avec Inc(PChar), c'est clairement efficace !

[e-ric]

Pour toutes les combinaisons de 7 caractères, bien sûr !
Pour choisir la taille des combinaisons dans ma démo, il suffit de sélectionner les premiers caractères avec la souris. En l'occurence je les ai tous pris.

C'est moins performant que le tien mais bon ç a me plaît bien

cdlt

[ShaiLeTroll]

Ben, si sur ma machine ton algo est plus rapide, relit bien !
Je donne mes temps et les tiens, car nos machines sont différentes ...
Sinon bien vu pour les préremplissage et le recalcul des valeurs ...

[e-ric]

j'utilise Inc naturellement (enfin quand j'y pense), souvenir du ++ du langage C. Le compilateur se livre à de "savantes" optimisations avec cette pseudo-procedure (prétendument déclarée dans l'unité system).

cdlt

[Gilbert Geyer]

J'ai à peine eu le temps de faire des essais que ça a encore bougé très vite ici ! (vous ne prenez pas le temps pour respirer parfois ? ).

nbCara :=5; ABCDE > 3 125 Combin's : 5 ms avec MemoryStream et 20 ms avec FileStream
nbCara :=6; ABCDEF > 46 656 Combin's : 75 ms avec MemoryStream et 285 ms avec FileStream
nbCara :=7; ABCDEFG > 823 543 Combin's : 6825 ms avec MemoryStream et 7695 ms avec FileStream pour 5630 Ko sans aucun #13#10

nbCara :=8; ABCDEFGH > 16 777 216 Combin's :
- avec MemoryStream : msg plus de mem pour de l'extension du flux !
- avec FileStream 2 min 55 sec soit 175 000 ms pour 131072 Ko sans aucun #13#10

Conclusions :
- Cela confirme, vos messages, que tant que la mem-vive n'est pas saturée MemStream est plus rapide que FileStream ...
- A propos des 6825 ms précitiés et dont je m'attendais que ma fameuse règle de 3 les abaisserait à 3162 ms on découvre en fait qu'ils passent à 7695 ms et que la règle de 3 est carrément fumeuse pour se faire une idée même approximative à partir d'une mesure effectuée sur un autre micro !!.

Après mes tests foudroyants de rapidité, voilà pas :
qu'Eric annonce : "Sur ma machine ... pour l'ensemble ABCDEFG, j'obtiens 120 ms ... et que ShaiLeTroll répond "... sur ma machine avec mon algo, le 7 c'est 45ms" ... c'est pas décourageant mais presque. Ce qui est bien avec ma machine c'est que si un code y tourne rapidement il en sera de même sur la machine de tout le monde. (avis aux développeurs professionnels).

En tous cas merci pour vos réponses.
Au fait, ShaiLeTroll dans ton message de 14h53 tu dis à propos "... de la Mémoire lente à trop grand volume à cause du SWAP, il suffit de mettre la colonne Erreur de Page dans le Gestionnaire des Taches, ...". : Je n'ai pas bien pigé, où puis-je trouver ce Gestionneur à cet effet ?

Bon week-end à tous les deux.

[ShaiLeTroll]

Il est dispo depuis Windows 2000

Tu l'as à partir du CTRL ALt SUP
Ou (en XP, 2K je ne sais plus), Clic Droit sur le Systray, "Gestionnaires des Taches", Onglet "Processus", Affichage "Selection des Colonnes"

Pour les traitements Mémoire et Fichiers, cela dépend vraiement des machines, suffit d'avoir un disque SCSI et il sera rapide pour les gros volumes de données, les démarrages sont plus lent, cela est résolu par l'ATA133, ... et maintenant je ne sais même plus quels noms ont les connecteurs ... même la qualité des controlleurs, des BIOS de la CM, influencent sur ce genre de traitement, le proc et le DD identique sur une machine avec deux CM différentes, tu auras des résultats différents, ... ensuite tu as les dual core/bi proc, qui changent le comportement, car un traitement mémoire sera fait sur un proc, et un traitement fichier lancé en asynchrone via API Windows pourrait être fait sur l'autre proc ...

[Gilbert Geyer]

A ShailLeTroll :

Merci pour ces infos. Sous Delphi 5 le CTRL ALt SUP ou un Clic Droit sur le Systray débouchent uniquement sur deux possibilités :
- "Création d'une tâche planifiée"
- "Démarrage du programme de réglages"
... bon, tant pis pour moi.

Au fait, si on résume la discussion depuis l'instant où Bativir l'a quittée en plaçant la balise [Résolu] devant l'intitulé les codes on été nettement améliorés vu que :
- le tien est le plus performant si on travaille entièrement en mémoire
- celui d'E-ric est optimisé pour envoyer les combinaisons au fur et à mesure sur le disque,
- et même celui sur lequel j'ai fait les tests de rapidité est n fois plus rapide que sa version initiale que Bativir a emportée en placant la balise [Résolu].
On fait quoi dans un tel cas, on lui fait un mail pour l'en informer?

[ShaiLeTroll]

Sous Delphi 5 le CTRL ALt SUP ou un Clic Droit sur le Systray

On parle de Windows là, pas de Delphi !
Le Gestionnaire des Taches cela m'étonne que tu ne connaissent pas, c'est la truc avant le graphique en Vert sur fond noir, c'est peu précis mais déjà utile, sinon il y a mieux dans Demarrer -> Executer "perfmon"

Sinon pour Bativir, comme tu veux, mais si ta méthode lui suffit, autant qu'il l'a conserve, mais pour faire son arrangement de 33 objets par 5, seul la méthode de E-ric par Fichier peu y apporter une réponse en un délai suffisant ... je voulais d'ailleurs pondre une version semi-mémoire, semi-fichier en stockant 2*32Mo de Données en Mémoire, et écriture de fichier par Thread d'un packet de 32 Mo ... avec un switch qui échange le paquet en process et le paquet en write, cela boosterait la performance nettement (l'opération lente de fichier laissant le temps à l'autre thread de calculer, et sur un dual core ou mieux, cela serait encore mieux)

[e-ric]

je voulais d'ailleurs pondre une version semi-mémoire, semi-fichier en stockant 2*32Mo de Données en Mémoire, et écriture de fichier par Thread d'un packet de 32 Mo ... avec un switch qui échange le paquet en process et le paquet en write, cela boosterait la performance nettement (l'opération lente de fichier laissant le temps à l'autre thread de calculer, et sur un dual core ou mieux, cela serait encore mieux)

Petit chipoteur

[Gilbert Geyer]

A ShaiLeTroll :

- "On parle de Windows là, pas de Delphi !" : Effectivement. Une inattention de ma part ... je voulais dire sous Windows 98.

- "Le Gestionnaire des Taches cela m'étonne que tu ne connaissent pas" : J'ai toujours peur de dérégler Windows, alors je n'y touche que pour des trucs basiques.

- "...mais si ta méthode ..." : C'est pas ma méthode, c'est une méthode produite initialement par E-ric et à propos de laquelle Bativir avait écrit "c'est exactement ce qu'il me faut, j'ai raccourci le code" et en joingant ce code. Je n'y ai apporté que les améliorations dues aux Streams. Mais comme tu dis si cette méthode suffit au principal intéressé ... on peut se contenter de savoir qu'elle lui suffit.

[ShaiLeTroll]

Windows 98, comme à la Maison, bon, il y a un moniteur qui traine sur le CD mais pas terrible car il bouffe lui même trop de puissance, et je m'en souviens plus trop (c'est même peut-être un programme externe de norton en fait, j'ai de vague souvenir) ... à la maison, je ne fais que jouer (oui avec mon vieille ordi sur win98, je joue avec des vieux jeux)

Sinon Le Gestionnaire des Taches, c'est vraiement juste de la surveillance, le CTRL+ALT+SUP amélioré de 2K, c'est qui remplace la petite liste de Win98 ...

et sinon fier d'être un "Petit chipoteur" ... et si j'ai le temps ... là je vais m'essayer sur la recherche de doublon ...

[Gilbert Geyer]

A ShaiLeTroll :

- "... là je vais m'essayer sur la recherche de doublon ..." : J'ai déjà commencé, par des tests comparatifs :

[CODE]
for i:=1 to 10000000 do IntegerList1.add(10000000); // 537 ms version CapJack
for i:=1 to 10000000 do IntegerList2.add(10000000); // 417 ms version Waskol
for i:=1 to 1000000 do IntegerList1.add(10000000); // 83 ms version CapJack
for i:=1 to 1000000 do IntegerList2.add(10000000); // 46 ms version Waskol

for i:=1 to 1000000 do StringList1.add(intToStr(10000000)); // 1189 ms soit 14 à 26 fois plus lent que les IntegerList (toujours sur 2CV cadencée 1.13 GHz)

[ShaiLeTroll]

Lol, l'utilisation de List que ce soit String ou Integer me fait sourire, sinon c'est une évidence qu'une liste stockant des entiers sans transformation ou parsing est plus rapide !

[Gilbert Geyer]

Effectivement qu'il s'agit d'une évidence ... mais ce qui n'était pas évident avant le test c'était l'aspect quantitatif c'est à dire combien de fois plus rapide ou plus lent.

Tu dis "l'utilisation de List que ce soit String ou Integer me fait sourire" sans préciser pourquoi. Ce sont pourtant des trucs très souples d'utilisation. Non ?

[ShaiLeTroll]

Non, c'est juste que le seul débat soit autour des listes alors que le sujet parle de manipulation de fichier et d'optimisation à ce sujet par un algo intelligent ... en fait, c'est cette phrase qui m'a fait sourire :

Au fait il me semble avoir vu qq part sur ce forum le code d'un "TIntegerList" qui contrairement à TStringList accepte posDeb etc sans nécessiter de conversion Longint>String et vice-versa et qui de plus éviterait les inconvénients des tableaux dits dynamiques... à vérifier

une Tlist ou TStringList c'est en fait un pointeur manipulé via GetMem/ReallocMem/FreeMem qui ne fait que pointé sur une variable considéré comme un tableau statique mais utilisé comme "typeur" de pointer donc c'est ni plus ni moins l'encapsulation d'un tableau dynamique à l'ancienne ...

comme le code suivant qui permettait en Delphi 3 de faire des tableaux dynamiques, fallait juste soit même géré les dimensions (les tableau mutli dimensions c'était la plaie à gérer je ne l'ai jamais fait, un simple Array[0..(MaxInt - 1) div 4] of Integer pouvait être manipulé avec un GetMem pour définir sa taille mais Length High Low biensur renvoyait n'importe quoi puisque le tableau était contourné juste en "typeur" de variable) ... les Tableau Dynamiques de Delphi 4 ayant résolu ce problème ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
procedure TFrmTestMemory.BtnPointerIntArray1024By256Click(Sender: TObject);
type
  PMatriceInteger1024By255 = ^TMatriceInteger1024By255;
  TMatriceInteger1024By255 = array [0..1023,0..255] of Integer;
  PMatriceString1024By255 = ^TMatriceString1024By255;
  TMatriceString1024By255 = array [0..1023,0..255] of string[8];
var
  Tableau : PMatriceInteger1024By255 ;
  TabStr : PMatriceString1024By255 ;
  PosH : Integer;
  PosV : Byte;
begin
    GetMem(Tableau, 1024*256*4);  
    for PosH := 0 to 1023 do
    begin
      for PosV := 0 to 255 do
      begin
        Tableau^[PosH][PosV]:= PosH*PosV;
      end; 
    end;
    FreeMem(Tableau);
 
    GetMem(TabStr, 1024*256*(8+1)); 
    for PosH := 0 to 1023 do
    begin
      for PosV := 0 to 255 do
      begin
        TabStr^[PosH][PosV]:= IntToStr(PosH) +'_'+ IntToStr(PosV);
      end;
    end;
    FreeMem(TabStr);
end;

[Gilbert Geyer]

A ShaiLeTroll :

- "Tlist ou TStringList ... c'est ni plus ni moins l'encapsulation d'un tableau dynamique à l'ancienne" : Tiens, j'aurais plutôt cru qu'il s'agissant d'une liste doublement chaînée de pointeurs où chaque cellule comporte un pointeur vers la précédente et un vers la suivante.

- A propos des tableaux dynamiques : Bien que plus souples d'utilisation qu'un tableau statique aux dimensions figées, le simple fait d'avoir à placer le SetLength à l'extérieur et en avant d'une boucle pour éviter les ralentissements qu'il engendrerait à l'intérieur de la boucle nécessite de prédire ou de sur-évaluer cette longueur hors boucle comme s'il s'agissait d'un tableau statique. En final l'appelation "dynamique" est à mon avis un peu pompeuse vu que les effets d'un SetLength interne à une boucle sont ceux d'un appui sur la pédale d'un frein. Et en plus, cette appelation est même une incitation à placer le SetLength dans une boucle pour faire varier la longueur du tableau de façon dite dynamique ... en freinant!
Bon, une fois qu'on le sait ça passe, mais y'en a beaucoup qui se laissent piéger par cette appelation.

[e-ric]

- "Tlist ou TStringList ... c'est ni plus ni moins l'encapsulation d'un tableau dynamique à l'ancienne" : Tiens, j'aurais plutôt cru qu'il s'agissant d'une liste doublement chaînée de pointeurs où chaque cellule comporte un pointeur vers la précédente et un vers la suivante.

Il suffit d'ouvrir l'unité Classes pour savoir, l'approche choisie est plus économique en mémoire et en gestion.

- A propos des tableaux dynamiques : Bien que plus souples d'utilisation qu'un tableau statique aux dimensions figées, le simple fait d'avoir à placer le SetLength à l'extérieur et en avant d'une boucle pour éviter les ralentissements qu'il engendrerait à l'intérieur de la boucle nécessite de prédire ou de sur-évaluer cette longueur hors boucle comme s'il s'agissait d'un tableau statique. En final l'appelation "dynamique" est à mon avis un peu pompeuse vu que les effets d'un SetLength interne à une boucle sont ceux d'un appui sur la pédale d'un frein. Et en plus, cette appelation est même une incitation à placer le SetLength dans une boucle pour faire varier la longueur du tableau de façon dite dynamique ... en freinant!
Bon, une fois qu'on le sait ça passe, mais y'en a beaucoup qui se laissent piéger par cette appelation.

Il n'y a pas de pièges ; de toutes façon, les structures dynamiques en taille variables travaillent toutes de la même façon globalement. Ce sont les choix d'implémentation et leur utilisation qui vont influer sur les performances. Il est clair que si l'on connaît par avance le nombre d'éléments d'un tableau dynamique, on a intérêt à allouer la place nécessaire en une seule fois.

cdlt

[Gilbert Geyer]

E-ric : Merci pour ces infos.

- "suffit d'ouvrir l'unité Classes pour savoir, l'approche choisie est plus économique en mémoire et en gestion" : Je te fais confiance là dessus ... car c'est pas certain qu'en ouvrant simplement l'unité je saurai automatiqment et spontanément que l'approche est plus économique.

- "Il n'y a pas de pièges" : Pas-pour-les fortiches-comme-toi ... mais piège pour débutants. Non?

[ShaiLeTroll]

Le Concept de Liste Chainée est très peu utilisé en Delphi ... c'est tout de même très lent comme principe de liste pour récupérer un item précis dans une grande liste

et je pense que ceci (extrait de l'aide D6) t'aurait suffit pour comprendre la TList est une encaspulation de tableau ...

Référence VCL

TList.List

Spécifie le tableau de pointeurs constituant le tableau Items.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
type
  TPointerList = array[0..MaxListSize-1] ofPointer;
  PPointerList = ^TPointerList;
 
property List: PPointerList;

Description

La propriété List donne un accès direct au tableau Items.

Ensuite un List.Add avec un Count + 1 qui dépace le Capacity, cela provoque une sorte de SetLength (ReAllocMem dans Grow) ... mais idem, suffit de mettre Capacity à la bonne taille si l'on connait à l'avance la taille finale de la liste, ...