Discussion :

[j.p.mignot]

si on utilise la stratégie 'setlength' on alloue facilement à discrétion de la mémoire 'typée' que l'on accroît facilement sans perdre la partie déjà allouée en accroissant le nombre d'élément.
Comment dé-allouer correctement cette mémoire?
J'utilise

Code :

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

1
2
3
 
SetLength(V,0);
V:=nil;

sans avoir vraiment vu si cela est OK si ce n'est par sources non certifiées.

Actuellement dans le doute j'utilise plutôt l'approche suivante qui est un peu + lourde du point de vue de la syntaxe mais pour laquelle je suis sur de déallouer la mémoire.
Par exemple:

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
 
const M=100; 
var p : pointer;
var d : ^double;
getmem(p,M*sizeof(double)); 
 
ReallocMem( P,newsize); // pour changer dynamiquement la taille et restituer au passage la mémoire si newsize < oldsize
 
d:=p;
for i:=0 to M-1 do
   begin
   d^:=....
   inc(d);
   end;
...
 
freemem(p);  // mémoire désallouée
p:=nil; // eventuel
...

[Qwazerty]

Salut
Apres quelques recherches, sauf erreur de ma part, tu peux tout simplement utiliser

Code :

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

Finalize(V);

[Edit]
Apres relecture de l'aide

Si la variable spécifiée lors d'un appel à Finalize ne contient pas de variants, de chaînes longues ni d'interfaces, le compilateur élimine l'appel et ne génère pas de code pour cet appel.

Dans ce cas, il semblerait qu'il faille faire appelle à Dispose.

En écrivant tout ceci, je me rend compte que je ne manipule pas souvent des emplacement mémoire, quelqu'un va certainement éclairer tout ça, parce qu'il faut tenir compte de ce qu'est V pour pouvoir te répondre a mon avis.

[/Edit]

++
Qwaz

[Paul TOTH]

alors bien souvent tu n'as pas à libérer ladite mémoire si c'est une variable locale à une fonction, le tableau sera automatiquement libéré en fin de fonction.

ensuite SetLength(x, 0) et x := nil sont équivalent, la seconde forme invoque directement DynArrayClear tandis que la première le fait en deux temps...

[Qwazerty]

Salut
Désolé de poser mes baguages dans ce post, mais qu'en est il de Dispose et Finalize?
++
Qwaz

[j.p.mignot]

Dispose est le pendant de l'opérateur 'New'

êtes-vous sur que faire simplement

V:=nil;

libère la mémoire?

J'ai des souvenirs (lointains) qu'avec TurboPascal sous DOS, mettre p:= nil perdait l'adresse mémoire mais ne désallouait pas une mémoire assignées pas getmem et qu'un appel à freemem était nécessaire. Mais j'ai pas ou très peu utilisé 'SetLength'.

[Paul TOTH]

Salut
Désolé de poser mes baguages dans ce post, mais qu'en est il de Dispose et Finalize?
++
Qwaz

Dispose() est le pendant de New()

FreeMem() est le pendant de GetMem()

Finalize() est appelé automatiquement pour les tableaux dynamiques et par Dispose()
il n'a besoin d'être utilisé que dans le cas d'une libération par FreeMem() d'un espace mémoire qui contiendrait des tableaux dynamiques ou des chaînes longues.

exemple

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
 
type
  TMonRecord = record
    Str: string;
  end;
  TDeuxRecord = array[0..1] of TMonRecord;
 
var
  R1: array of TMonRecord;
  R2: ^TDeuxRecord;
  R3: ^TMonRecord;
  R4: ^TMonRecord;
begin
  SetLength(R1, 2);
  R1[0].Str := 'Hello';
  R1[1].Str := 'Hello';
  R1 := nil; // rien à faire de particulier
 
  New(R2);
  R2[0].Str := 'Hello';
  R2[1].Str := 'Hello';
  Dispose(R2); // rien à faire de particulier
 
  GetMem(R3, 2 * SizeOf(TMonRecord));
  R3.Str := 'Hello';
  R4 := R3;
  Inc(R4); // Second TMonRecord pointé par R3
  R4.Str := 'Hello';
  Finalize(R3, 2); // Libère les deux Str car personne ne le fera pour vous
  FreeMem(R3);
end;

[sjrd]

Pour compléter, j'ajouterais que :

Code :

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

New(P);

est équivalent à

Code :

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

1
2
GetMem(P, SizeOf(P^));
Initialize(P); // en gros met à 0 si nécessaire

Et

Code :

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

Dispose(P);

est équivalent à

Code :

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

1
2
Finalize(P^);
FreeMem(P);

De plus, pour les variables non pointeurs, Initialize est appelée automatiquement en début de méthode, et Finalize en fin de méthode dans un try..finally implicite.

Ainsi, si j'ai une variable de type TStringDynArray :

Code :

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

1
2
3
4
5
6
var
  Arr: TStringDynArray;
begin
  SetLength(Arr, 3);
  // bla bla
end;

Le compilateur transforme ça tout seul en

Code :

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

1
2
3
4
5
6
7
8
9
10
11
var
  Arr: TStringDynArray;
begin
  Initialize(Arr);
  try
    SetLength(Arr, 3);
    // bla bla
  finally
    Finalize(Arr);
  end;
end;

Donc pour les tableaux dynamiques, il ne faut tout simplement pas s'occuper de la gestion de la mémoire : le langage le prend en charge tout seul.
C'est tout l'intérêt d'ailleurs, sinon on retourne aux bons vieux tableaux statiques alloués dynamiquement.

[sjrd]

Et attention le dernier code de Paul Toth est buggué :

Code :

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

1
2
3
4
5
6
7
  GetMem(R3, 2 * SizeOf(TMonRecord));
  R3.Str := 'Hello';
  R4 := R3;
  Inc(R4); // Second TMonRecord pointé par R3
  R4.Str := 'Hello';
  Finalize(R3, 2); // Libère les deux Str car personne ne le fera pour vous
  FreeMem(R3);

Il manque un Initialize :

Code :

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

1
2
  GetMem(R3, 2 * SizeOf(TMonRecord));
  Initialize(R3^, 2);

[Qwazerty]

SAlut
Et donc si j'ai bien suivi

Code :

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

Finalize(R3, 2); // Libère les deux Str car personne ne le fera pour vous

devrait donc être

Code :

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

Finalize(R3^, 2); // Libère les deux Str car personne ne le fera pour vous

Mais puisque R3 est déclaré en ^TMonRecord, est ce qu'on devrait plutôt pas garder

Code :

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

Finalize(R3, 2); // Libère les deux Str car personne ne le fera pour vous

et donc du coup avoir

Code :

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

Initialize(R3, 2);

au lieu de

Code :

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

Initialize(R3^, 2);

++
Qwaz

[Paul TOTH]

non, sjrd a parfaitement raison, voici le code corrigé

j'ai ajouté un type PMonRecord car "R4 := R3" ne passe pas sinon

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
 
type
  TMonRecord = record
    Str: string;
  end;
  TDeuxRecord = array[0..1] of TMonRecord;
  PMonRecord = ^TMonRecord;
 
procedure test;
var
  R1: array of TMonRecord;
  R2: ^TDeuxRecord;
  R3: PMonRecord;
  R4: PMonRecord;
begin
  SetLength(R1, 2);
  R1[0].Str := 'Hello';
  R1[1].Str := 'Hello';
  R1 := nil; // rien à faire de particulier
 
  New(R2);
  R2[0].Str := 'Hello';
  R2[1].Str := 'Hello';
  Dispose(R2); // rien à faire de particulier
 
  GetMem(R3, 2 * SizeOf(TMonRecord));
  Initialize(R3^, 2);
  R3.Str := 'Hello';
  R4 := R3;
  Inc(R4); // Second TMonRecord pointé par R3
  R4.Str := 'Hello';
  Finalize(R3^, 2); // Libère les deux Str car personne ne le fera pour vous
  FreeMem(R3);
end;