Discussion :

[Art19]

Bonjour,

J'ai un pointeur que je voudrais convertir en Double mais je ne sais pas comment faire! (je suis debutant):

Code :

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

1
2
3
4
5
6
7
8
9
 
 
  SetLength( tab, listTab.Count );
 
  for i := 0 to listTab.Count-1 do begin
 
    tab[i] := listTab[i];
 
  end;

ici tab est un array of double alors que listTab est une TList.

[Pedro]

Salut
Il ne marche pas ce code?

[Art19]

Non delphi me dit "Incompatible types" entre Pointer et Double

[Art19]

ce que j'ai fait c'est que j'ai construit une classe avec un champ double et j'ai ajoute une instance de classe a ma liste mais je trouve que c'est un peu bourrin comme solution. Donc si vous avez une idee... je prend

[Pedro]

Essaie à tout hasard:

Code :

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

tab[i] := integer(listTab[i]);

[Art19]

moi c'est cense etre un FLOAT ! pas un Integer..

[gb_68]

Bonjour,

les éléments d'une TListe sont des pointeurs ; donc pour y mettre un élément, il faut l'allouer dans le tas (New(), MemAlloc,...) et passer son pointeur à la liste.

Il existe l'astuce (par toujours très sage) de mettre la donnée elle-même dans la liste au lieu de son adresse en transtypant la donnée en un pointeur (qu'il ne faudra bien sur jamais déférencer ), mais cela suppose que la donnée occupe 4 octets (ou moins), soit la taille d'un pointeur.
Or un double fait 8 octets (donc ce n'est pas possible).

[Pedro]

moi c'est cense etre un FLOAT ! pas un Integer..

As-tu essayé ceci:

Code :

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

1
2
3
4
5
6
7
 
var
  i: integer;
  d: double;
begin
  d := i;
end;

Ben figure-toi que ça marche... Un entier peut être inscrit dans un réel. L'inverse est faux par contre.

[gb_68]

Les objets sont (implicitement) des pointeurs et possède leur propre liste TObjectList (qui peut gérer la libération de ces derniers et qui dérive de TList).

Mais un objet par Double ...

En utilisant des PDouble, il est possible de dériver la liste pour gérer la libération des pointeurs (comme le fait TObjectList ).

Pour un exemple d'usage avec des pointeurs (PDouble) :

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
 
  TListeDouble = class(TList)
  protected
     procedure Notify(Ptr: Pointer; Action: TListNotification); override;
  end;
 
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
    List : TListeDouble;
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
{ TListeDouble }
 
procedure TListeDouble.Notify(Ptr: Pointer; Action: TListNotification);
begin
  case Action of
    lnAdded     : ;
    lnExtracted : ;
    lnDeleted   : Dispose(Ptr);
  end;
end;
 
function NewDouble( ADouble : Double) : Pointer;
var ptrDouble : PDouble ;
begin
   New(ptrDouble);
   ptrDouble^ := ADouble;
   Result := ptrDouble;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
   List := TListeDouble.Create;
   List.Add( NewDouble( 10.23 ) );
   List.Add( NewDouble( 10402.40 ) );
   List[0] := NewDouble( 10.01 );
   ShowMessage( FloatToStr( PDouble(List[1])^ ) );
   List.Free;
end;

On peut aussi attendre les templates en Delphi (bientôt, bientôt ...)

[Pedro]

Tiens d'ailleurs, au passage, quel est l'intérêt de faire ça?

[gb_68]

c'est toujours mieux qu'un objet par double

pour l'intérêt réel de la chose ... je cherche, je cherche, bon j'ai pas encore trouvé

Sinon les 'Single' font 4 octets donc ceci passe (mais j'ai pas dit que c'était bien de faire ça) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TForm1.Button1Click(Sender: TObject);
var A : Single ; AList : TList;
begin
   AList := TList.Create;
   A := 10.0;
   AList.Add(Pointer(A));
   A := 0.0;
   A := Single(AList[0]);
   ShowMessage( FloatToStr(A));
   AList.Free;
end;

Enfin il y a les tableaux dynamiques (ils sont bien en Delphi, on connait leur taille,on peut les redimensionner, ils sont gérés de manière transparente en mémoire, ... ).

[droggo]

Kio,

Un jour, quand je serai très vieux, je me poserai probablement encore la question:

Pourquoi vouloir mettre un Single à la place destinée à un pointeur ?

C'est typiquement le genre de code qu'il faut éviter. Tu veux utiliser un single, tu utilises une variable de ce type.

[Art19]

j'ai evite les tableaux dynamiques parce que j'avais un Out of Memory dans mon programme!

[ShaiLeTroll]

lol, un OutOfMemory avec un Tableau Dynamique, c'est qu'il devait être très mal déclaré, ...

sinon, le plus sympa c'est effectivement de reprendre l'exemple de gb_68, mais en l'améliorant en surchargeant ADD, Delete, Clear, ... pour passer un double en paramètre, tient un peu comme ce code, je l'ai modifié d'une liste contenant des structures, pour un type modèle à la place, c'est un template, suffit de remplacer TModeleType par Double et PModeleType par PDouble, et cela fonctionne sans soucis

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
 unit uModeleTypeList;
 
interface
 
uses Classes;
 
type
  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.