Discussion :

[tintin62]

Bonjour
Voila mon probleme
jai un record a plusieurs champ
que je defini dans type
que je defini ensuite dans var
par array[0..300000] du record
voir exemple ci dessous

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
 
type
layer_line= record
 
             nom:string;
             xt:string;
           yt:string;
            zt:string;
             xxt:string;
              yyt:string;
               zzt:string;
               end;
 
 
 
  TForm1 = class(TForm)
    Button1: TButton;
    OpenPictureDialog1: TOpenPictureDialog;
    OpenDialog1: TOpenDialog;
    Memo1: TMemo;
    monbb: TImage;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
       end;
 
var
  Form1: TForm1;
   line:array [0..300000] of layer_line;
 
   l:integer;
implementation

ensuite pour valider un champ je fais
line[1].nom:=....
line[1].xt:=....

ma question est
comment definir un array en virtuel sans donner de valeur la jai mis
300000 car des fois sa sera 10000 ou plus de 300000
jai vu la commande setlength(line,length(line+1) mais sa marche pas
jai des message comme memoire insuffisante


jespere ma voir fait comprendre
merci pour votre aide

[J_apprenti]

Essaye ceci:

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
 
type
TLayer_line = record
  nom: string;
  xt: string;
  yt: string;
  zt: string;
  xxt: string;
  yyt: string;
  zzt: string;
 end;
 
TTableauLayer_line = array of Tlayer_line;
 
var
 line: TTableau_Layer_line;

et puis:

Code :

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

1
2
 
SetLength(line, length(line) + 1);

a+

[archonte]

Structure étrange ! mais bon. Je pense que tu n'as pas déclaré ton tableau en tableau dynamique :

Code :

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

var line : array of layer_line;

puis dans une procedure ou fonction :

Code :

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

1
2
3
4
5
begin
...
  setlength(line, n); // il te reste à définir n
...
end;

[EDIT] Grillé

[tintin62]

Bonjour
Merci pour vos reponses
sa marche mais javais encore une erreur
memoire insuffisante
jai modifie mon record

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
Tlayer_line= record
 
             nom:string[10];
             xt:string[10];
           yt:string[10];
            zt:string[10];
             xxt:string[10];
              yyt:string[10];
               zzt:string[10];
               end;
 
 TTableau_Layer_line = array of Tlayer_line;

sa marche
Mais y a til une limite pour le stokage a par le nombre de
ram memoire

+++

[J_apprenti]

oui c'est 2G je pense

puisque c'est plus de 300000 champs pourquoi ne pas s'en servir des pointeurs ?

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
 
type
  Tlayer_line = record
   nom: string[10];
   xt: string[10];
   yt: string[10];
   zt: string[10];
   xxt: string[10];
   yyt: string[10];
   zzt: string[10];
  end;
 
 PLayer_line = ^Tlayer_line;
 
 TTableauLayer_line = array of PLayer_line;

encore mieux et de créer une classe dérivé de TList pour gérer ton Tableau comme ceci:

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
 
 
type
 
  Tlayer_line = record
   nom: string[10];
   xt: string[10];
   yt: string[10];
   zt: string[10];
   xxt: string[10];
   yyt: string[10];
   zzt: string[10];
  end;
 
 PLayer_line = ^Tlayer_line;
 
 TLayer_lineList = class(TList)
  private
    procedure SetRecord(Index: Integer; Ptr: PLayer_line);
    function GetRecord(Index: Integer): PLayer_line;
  public
    procedure Clear;
    destructor Destroy; override;
    procedure DelRecord(Index: Integer);
    property Records[i: Integer]: Player_line read GetRecord write SetRecord;
  end;
 
//.. dans implementation
 
{ TLayer_lineList }
 
procedure TLayer_lineList.Clear;
var
  I: Integer;
begin
  for I := (Count - 1) downto 0 do
    DelRecord(I);
  inherited Clear;
end;
 
procedure TLayer_lineList.DelRecord(Index: Integer);
var p: PLayer_line;
begin
  if Index in [0..Count-1] then
  begin
     p:= Records[Index];
     if p <> nil then
     begin
        Dispose(p);
        Delete(Index);
     end;
  end;
end;
 
destructor TLayer_lineList.Destroy;
begin
  Clear;
  inherited;
end;
 
function TLayer_lineList.GetRecord(Index: Integer): PLayer_line;
begin
 Result:= PLayer_line(Items[Index]);
end;
 
procedure TLayer_lineList.SetRecord(Index: Integer; Ptr: PLayer_line);
var
  p: PLayer_line;
begin
  p:= Records[index];
  if p <> Ptr then
  begin
    if p <> nil then
      Dispose(p);
    Items[index]:= Ptr;
  end;
end;

et puis:

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
 
 
var
  line: TLayer_lineList;
  NewItem: PLayer_line;
 
 
  line:= TLayer_lineList.Create;
 
  // pour ajouter un record
  New(NewItem);
  NewItem^.nom:='s';
  //...
  line.Add(NewItem);
 
 
  //pour modifier ou lire un record
    line.Records[X]^.nom
 
 
   line.Free;

a+

[tintin62]

Bonjour
merci
Je pense que tu as raison de faire une class
derive Tlist
mais suis pas trop a aise avec sa
si par contre je me sert des pointeurs comme ton 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
 
type
  Tlayer_line = record
   nom: string[10];
   xt: string[10];
   yt: string[10];
   zt: string[10];
   xxt: string[10];
   yyt: string[10];
   zzt: string[10];
  end;
 
 PLayer_line = ^Tlayer_line;
 
 TTableauLayer_line = array of PLayer_line;

pour en creer un je dois faire sa ?
a:=a+1;
new(TTableauLayer_line[a])
et pour le detruire
dispose(TTableauLayer_line[a])
pour y acceder TTableauLayer_line[a].nom:=.....

dois aussi reserver de la memoire ou pas avec freemen ?

merci si j'y arrive pas il faudra bien que je m'y mets
au objet

+++

[ShaiLeTroll]

autant utilisé une TList avec des PLayer_line (tu n'es pas obligé de faire un héritage, mais c'est vrai que cela éviterait les transtypages permanent)
ou les génériques si c'est possible


l'allocation sera fait par paquet en plus, sachant qu'en interne de la TList c'est un pointeur sur un array[0..MaxInt div 16], le maximum possible !

Pour la mémoire, c'est bien 2Go maximum, perso, j'ai pu au maximum alloué 1960Mo !
Qui fonctionne en Alloc et FreeMem justement, le seul moyen de faire des tableaux dynamique en Delphi 3 !

Sinon, la surchage d'une TList, c'est plus simple que les pointeurs

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
unit uModeleTypeList;
 
interface
 
uses Classes;
 
type
  TModeleType = Double; // A Titre d'Exemple ... tu peur mettre Layer_line
  PModeleType = ^TModeleType;
 
  TModeleTypeList = class(TList)
  protected
    function GetItem(const Index: Integer): TModeleType;
    procedure SetItem(const Index: Integer; const Value: TModeleType);
  public
    function Add(const AModeleType: TModeleType): Integer;
    procedure Clear; override;
    procedure Delete(const Index: Integer);
    procedure Insert(const Index: Integer; const AModeleType: TModeleType);
    function First: TModeleType;
    function Last: TModeleType;
    // Propriétés
    property Items[const Index: Integer]: TModeleType read GetItem write SetItem; default;
  end;
 
 
implementation
 
// TModeleTypeList -------------------------------------------------------------
//                                                                             -
//                    TModeleTypeList - Protected                              -
//                                                                             -
// TModeleTypeList -------------------------------------------------------------
 
// TModeleTypeList - Protected -------------------------------------------------
function TModeleTypeList.GetItem(const Index: Integer): TModeleType;
begin
     // On veut une Structure ModeleType, et n'ont pas un pointeur, donc déférencement (^)
     Result := PModeleType(inherited Items[Index])^;
end;
 
// TModeleTypeList - Protected -------------------------------------------------
procedure TModeleTypeList.SetItem(const Index: Integer; const Value: TModeleType);
begin
     // On veut une Structure ModeleType, et n'ont pas un pointeur, donc déférencement (^)
     PModeleType(inherited Items[Index])^ := Value;
end;
 
// TModeleTypeList -------------------------------------------------------------
//                                                                             -
//                     TModeleTypeList - Public                                -
//                                                                             -
// TModeleTypeList -------------------------------------------------------------
 
// TModeleTypeList - Public ----------------------------------------------------
function TModeleTypeList.Add(const AModeleType: TModeleType): Integer;
var
   TmpModeleType: PModeleType;
begin
     New(TmpModeleType);
     TmpModeleType^ := AModeleType;
     Result := inherited Add(TmpModeleType);
end;
 
// TModeleTypeList - Public ----------------------------------------------------
procedure TModeleTypeList.Clear;
var
   Index: Integer;
begin
     for Index := Count - 1 downto 0 do begin
         if Assigned(inherited Items[Index]) then begin
            Dispose(PModeleType(inherited Items[Index]));
         end;
     end;
 
     inherited Clear();
end;
 
// TModeleTypeList - Public ----------------------------------------------------
procedure TModeleTypeList.Delete(const Index: Integer);
begin
     Dispose(PModeleType(inherited Items[Index]));
 
     inherited Delete(Index);
end;
 
// TModeleTypeList - Public ----------------------------------------------------
procedure TModeleTypeList.Insert(const Index: Integer; const AModeleType: TModeleType);
var
   TmpModeleType: PModeleType;
begin
     New(TmpModeleType);
     TmpModeleType^ := AModeleType;
     inherited Insert(Index, TmpModeleType);
end;
 
// TModeleTypeList - Public ----------------------------------------------------
function TModeleTypeList.First: TModeleType;
begin
     // On veut un ModeleType, et n'ont pas un pointeur, donc déférencement (^)
     Result := PModeleType(inherited First())^;
end;
 
// TModeleTypeList - Public ----------------------------------------------------
function TModeleTypeList.Last: TModeleType;
begin
     // On veut un ModeleType, et n'ont pas un pointeur, donc déférencement (^)
     Result := PModeleType(inherited Last())^;
end;
 
end.
 
end.

[tintin62]

Merci
vais essayer ta methode
merci encore
++