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
| { TBaseCtn }
PBaseCtn = ^TBaseCtn;
TBaseCtn = Object
private
// Capacité de stockage du tableau en nb d'éléments{ 4 bytes }
FCapacity : PtrUInt;
// Nombre d'éléments actifs du tableau { 4 bytes }
FCount : PtrUInt;
// Structure TypeInfo { 4 bytes }
//FElTypeInfo : PTypeInfo;
// taille en bytes des éléments du tableau { 2 bytes }
FElementSize : Word;
// Pointeur tableau dynamique { 4 bytes }
FMemStart : pointer;
// Pointeur vers le curseur de navigation
FMemCursor : Pointer;
protected
{ SetCapacity : Màj la capacité de stockage du tableau }
procedure SetCapacity( aNewCapacity : PtrUInt); {$ifdef HASINLINE}inline;{$endif}
{ Expand : Elargit la taille en mémoire }
procedure Expand;
{ Get : Retourne pointeur vers l'éléement de l'index demandé }
function Get(aIndex: PtrUInt): Pointer; {$ifdef HASINLINE}inline;{$endif}
{ Put : Initie le pointeur de l'élement demandé }
procedure Put(aIndex: PtrUInt; aElementPtr: Pointer);
public
{ Init : Initialisation du tableau et de la taille de l'élément à stocker }
procedure Init(aCapacity: PtrUInt; aElementSize: Word);
{ Free : Libére la mémoire et RAZ les variables du conteneur}
procedure Free;
{ Add : Ajoute un élément en fin de tableau }
function Add(const Element): PtrUInt; {$ifdef HASINLINE}inline;{$endif}
{ Insert : Insére un élément à l'index passé en paramétre }
procedure Insert(aIndex : PtrUInt; const aElement);{$ifdef HASINLINE}inline;{$endif}
{ Clear : Vider le tableau en désallouant le pointeur en mémoire }
function Clear: Boolean;
{ Delete : Supprime un élément du tableau selon l'index informé }
function Delete(aIndex: PtrUInt): Boolean; {$ifdef HASINLINE}inline;{$endif}
{ Capacity : Determine la capacité de sockage du tableau }
property Capacity : PtrUInt read FCapacity write SetCapacity;
{ Count : Retourne le nombre d'élements stockés dans le tableau}
property Count : PtrUInt read FCount;
{ Items : Determine le pointeur de stockage pour l'indice demandé }
property Items[aIndex: PtrUInt]: Pointer read Get write Put; // default;
end;
implementation
{ TBaseCtn }
procedure TBaseCtn.SetCapacity(aNewCapacity: PtrUInt);
begin
if aNewCapacity = FCapacity then exit; { si la taille ne change pas alors sortie }
if aNewCapacity = 0 then { Si nouvelle taille = 0 alors }
Clear { On vide la memoire }
else
begin
if not Assigned(FMemStart) then { Si le tableau n'existe pas }
GetMem(FMemStart, aNewCapacity * FElementSize) { On affecte la mémoire à la taille demandée}
else { sinon ... }
ReAllocMem(FMemStart, aNewCapacity * FElementSize); { On modifie la taille du tableau }
FCapacity := aNewCapacity; { Capacité = taille demandée }
end;
end;
procedure TBaseCtn.Expand;
begin
end;
function TBaseCtn.Get(aIndex: PtrUInt): Pointer;
begin
// Result := nil; { Initie le resultat à nul }
// if (aIndex > FCount-1) then exit; { Si index est sup. au nombre d'elemenets alors exit }
Result := Pointer(PtrUInt(FMemStart)+(aIndex*FElementSize));
end;
procedure TBaseCtn.Put(aIndex: PtrUInt; aElementPtr: Pointer);
begin
Move(aElementPtr^, (FMemStart+(aIndex * FElementSize))^, FElementSize);
end;
procedure TBaseCtn.Init(aCapacity: PtrUInt; aElementSize: Word);
begin
if (aCapacity < 1) or (aElementSize < 1) then Exit;
FCapacity := 0;
FCount := 0;
FElementSize := aElementSize;
FMemStart := nil;
SetCapacity(aCapacity);
end;
procedure TBaseCtn.Free;
begin
if Assigned(FMemStart) then
begin
Clear;
Freemem(FMemStart, FCapacity * FElementSize ); { On le libére de la mémoire }
FCapacity := 0; { Maj capacité tableau }
FMemStart := nil; { Affectation pointeur à VIDE}
end;
end;
function TBaseCtn.Add(const Element): PtrUInt;
begin
//Result := 0; { Initie le resultat à 0 }
//if FCount = FMemCapacity then Expand;{ Si liste pleine alors augmente taille liste }
Move(Element, (FMemStart+(FCount * FElementSize))^, FElementSize);{ Copie Element dans le tableau de valeurs }
Inc(FCount); { Incrémente le compteur de 1 position }
//asm
// MOV EAX, FCount; // Copie la valeur de Fcount à l'accumulateur AEX
// ADD EAX, 1 // Incrémente l'accumulateur de 1
// MOV FCount, EAX // Copie la valeur de l'accumulateur dans la variable FCount
//end;
result := FCount; { Retourne la position du pointeur }
end;
procedure TBaseCtn.Insert(aIndex: PtrUInt; const aElement);
begin
end;
function TBaseCtn.Clear : Boolean;
begin
if not Assigned(FMemStart) then Exit;
try
Result := False;
FillChar(FMemStart, FCapacity * FElementSize, 0); { Initie à vide les blocs du tableau }
finally
FCount := 0; { Maj nb éléments }
Result := True;
end;
end;
function TBaseCtn.Delete(aIndex: PtrUInt) : Boolean;
begin
try
result := False;
FillByte((FMemStart + (aIndex * FElementSize))^, FElementSize, $00); { Similaire à ZeroMemory de Delphi }
finally
Dec(FCount);
Result := True;
end;
end; |
Vider un bloc mémoire
Répondre avec citation
Partager