Tableau Array record

Version imprimable

;)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:

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
:cry:jai des message comme memoire insuffisante

jespere ma voir fait comprendre
merci pour votre aide

:salut:
Essaye ceci:

Code:

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:

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

19/08/2010, 22h31
archonte
Structure étrange ! mais bon. Je pense que tu n'as pas déclaré ton tableau en tableau dynamique :

Code:

var line : array of layer_line;

puis dans une procedure ou fonction :
Code:

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

[EDIT] :evilred: Grillé :furax:

;)Bonjour
:ccool:Merci pour vos reponses
sa marche mais javais encore une erreur
memoire insuffisante:cry:
8Ojai modifie mon record
Code:

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;
:ccool:sa marche
Mais y a til une limite pour le stokage a par le nombre de
ram memoire

+++
:lol:

:salut:

oui c'est 2G je pense :oops:

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

Code:

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:

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:

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+ :wink:

;)Bonjour
:ccool:merci
Je pense que tu as raison de faire une class
derive Tlist
:oops:mais suis pas trop a aise avec sa
si par contre je me sert des pointeurs comme ton exemple
Code:

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

+++:mrgreen:

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 ! :mrgreen:

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

Code:

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.

24/08/2010, 22h03
tintin62

:)Merci
vais essayer ta methode :ccool:
merci encore
++
;)