Discussion :

[LaDent]

Bonjour, plutot débutant en delphi, je developpe en ce moment deux classes qui contiennent chacune un tableau de Record chacun d'un type différent.

Existe t'il un moyen qui permette d'utiliser une même fonction (située dans une unité commune) pour, par exemple, parcourir ou trier mes tableaux.

je cherche donc à faire dans une unité commune une fonction du type :

TriArray(Adresse MonTableau, TypeDeRecord) : Boolean

qui serrait appelée par dans chaque classe par la fonction MaClasse.Tri();

si quelqu'un a la moindre idée, que ce soit par les pointeurs ou autre.. merci d'avance

[Jipété]

Yop !

Une première idée :

Code :

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

1
2
 
TriArray(Adresse_MonTableau: integer; MyRecord: TTypeDeRecord) : Boolean

appelée par la fonction MaClasse.Tri(Adresse_MonTableau, MyRecord);
et c'est dans ta fonction "Tri" que la vie se passe ?

Mes 2 cts,
--
jp

[edam]

bah, tu peut passé au 2éme vitesse, en utlisant TClientDataset
voir: ici et aussi si les modérateur le permet ici
bon dev

[e-ric]

Salut

Sauf à mettre en oeuvre une fonction maniant des pointeurs, c'est impossible directement, le contrôle de type est très strict avec les record.

Par contre, en transformant les types enregistrement en classe et en généralisant les deux classes obtenues (en créant une classe ancêtre commune), cela devient possible via le polymorphisme.

Mais concevoir une hiérarchie uniquement pour résoudre un simple problème de tri me paraît malgré tout abusif.

La technique mettant en jeu des pointeurs paraît plus artisanale mais elle est peut-être plus efficace en termes de réalisation. Cependant il va falloir jouer avec des pointeurs de données et de fonctions (comparaisons, échanges de données...), cela peut rendre la procédure de tri assez "ésotérique". Si en plus tu es débutant, il vaut mieux rester dans un domaine technique plus abordable (pour le reste on verra plus tard).

Une bonne solution apparaît dès lors : tu écris une routine de tri dans chacune des classes contenant les tableaux. C'est plus efficace et te donne plus de liberté quant aux options techniques pour chacun des tris (tu peux ainsi choisir des forme de tri différentes en fonction de tes données).

cdlt

e-ric

[LaDent]

bien, à vrai dire, il n'y a pas que la fonction de tri qui doit être partagée mais la plupart des fonctions de mes classes donc je vais perseverer un peu... j'ai essayé d'utiliser :

un pointeur sur tableau pour acceder aux données mais je ne vois pas comment fournir à la fonction le type de pointeur (qui change selon le type de record...) pour pouvoir deferencer ensuite..

de dériver mes deux classes d'un type de base, mais le tableau étant définit dans les classes dérivées (afin de pouvoir le definir du bon type de Record), comment mes fonctions definies dans la classe de base pouront elles acceder au tableau.. pour le moment j'ai une erreur de compilation tout a fait logique du type.... Identificateur non déclaré.... qui pointe à la première ligne referencant le tableau... ce dernier n'existant effectivement pas dans la classe de base... quelqu'un pour m'expliquer ce que j'ai pris de travers ? :-$

Dernier point... Delphi proposer à priori la possibilité de mettre un Case dans une définition de record pour lui permettre de prendre différentes formes en fonction de la valeur d'une de ces variables.... es ce une methode utilisée et optimale? .... cela me permettrait de réunir les Record sous un même type et donc de passer le tableau en param à mes fonctions partagées sans souci de type...

Merci pour la rapidité de vos premier posts !!

[Louis Griffont]

Le type Record avec partie variable marche tres bien.
Même si c'est parfois lourd à gérer !

[edam]

Bonjour, plutot débutant en delphi,

Pas vraiment débutant que sa d'après ton dernier poste
Mais quand j'ai parlé de TClientDataset, c'est vraiment intéressant, et si tu insistes d’utiliser les tableaux au moins allé voir le code source de TDataset pour voir comment géré différent type,

[e-ric]

re-salut

en créant des classes de tri (une classe générique et ses dérivées en fonction des type enregistrement), on arrive à un code tel que (non testé, ni compilé) :

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
interface 
 
TSorter = class
private 
  FDataStart: Pointer;
  FDataSize: Integer;
protected
  function GetDataSize: Integer; virtual; abstract;
  property Length: Integer read FLength;
  procedure Swap(I1, I2: Integer); virtual; abstract;
  function Compare(I1, I2: Integer); virtual; abstract;  
  procedure Sort(L, R: Integer);
  function GetData(Index: Integer): Pointer;
  property Data[Index: Integer]: Pointer read GetData;
public  
  procedure Execute(DataStart: Pointer; Length: Integer);
End;
 
PPersonne = ^TPersonne;
TPersonne = record
  Nom: string;
  Prenom: string;
end;
 
TPersonneSorter = class(TSorter)
protected
  function GetPersonne: TPersonne;
  procedure SetPersonne(Index: Integer; Value: TPersonne);
  function GetDataSize: Integer; override;
  procedure Swap(I1, I2: Integer); override;
  function Compare(I1, I2: Integer); override;
  function Personne[Index : Integer]: TPersonne read GetPersonne write SetPersonne;
End;
 
 
implementation
 
function TSorter.GetData(Index: Integer): Pointer;
begin
  // Retourne l'élément de rang Index
  Result := FDataStart + Index * FDataSize;
End;
 
// QuickSort
procedure TSorter.Sort(L, R: Integer);
var
  I, J: Integer;
  M: Pointer;
begin
  repeat
    I := L;
    J := R;
    M := Data[(L + R) shr 1];
    repeat
      while (Compare(Data[I], M)) < 0 do
        Inc(I);
      while (Compare(Data[J], M)) > 0 do
        Dec(J);
      if I <= J then
      begin
        Swap(Data[I], Data[J]);          
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then
      Sort(L, J);
    L := I;
  until I >= R;
End;
 
procedure TSorter.Execute(DataStart: Pointer; Length: Integer);
begin
  FDataStart := DataStart;
  FDataSize := GetDataSize; // Initialise la taille des éléments à trier
  Sort(0, Length);
End;
 
{ TPersonneSorter }
 
function TPersonneSorter.GetPersonne(Index : Integer): TPersonne;
begin
  Result := TPersonne(Data[Index])^;
End;
 
procedure TPersonneSorter.SetPersonne(Index: Integer; Value: TPersonne);
begin
  with TPersonne(Data[Index])^ do
  begin
    Nom := Value.Nom;
    Prenom := Value.Prenom;
  end;
End;
 
function TPersonneSorter.GetDataSize: Integer;
begin
  Result := SizeOf(TPersonne);
End;
 
function TPersonneSorter.Compare(I1, I2: Integer); 
begin
  // Compare d'abord les noms  
  Result := CompareText(Personne[I1].Nom, Personne[I2].Nom);
  if Result = 0 then
    // en cas d'égalité, compare les prénoms
    Result := CompareText(Personne[I1].Prenom, Personne[I2].Prenom);
End;
 
procedure TPersonneSorter.Swap(I1, I2: Integer); 
var
  P: Personne;
begin
  P := Personne[I1];
  Personne[I1] := Personne[I2];
  Personne[I2] := P;
End;
 
  // exemple d'utilisation
 
var
  T : array[0..10] of TPersonne;
  PS: TPersonneSorter;
begin
  // Remplissage du tableau
  // ...
  // Tri
  PS := TPersonneSorter.Create;
  try
    PS.Execute(@T[0], Length(T));
  finally
    FreeAndNil(PS);
  end;

Un des avantages de la méthode est que l'algorithme est écrit une fois pour toutes.

cdlt

e-ric

[Louis Griffont]

Tu peux aussi utiliser les TObjectList ou même les TCollection et TCollectionItem