Discussion :

[ero-sennin]

Si je te dis que je n'ai jamais vu l'audit d'erreur fonctionner correctement , ça répond a ta question ?

Heureusement, le compilateur lui travaille correctement.

En effet, la preuve avec mon code

Disons qu'il n'y a pas UN compilateur mais plusieurs.

J'apprends quelque chose là...

Le "compilateur" qui fait l'audit de code, l'autocompletion... s'appelle le compilateur Kibitz. Ce dernier doit être capable de travailler du source incomplet, avec des erreurs de syntaxe... et surtout, il s'exécute dans l'IDE pendant la saisie du code. Il faut qu'il consomme peu de ressources.
En un mot, il ne peut pas faire une compilation complète de l'ensemble du source et se base sur différentes heuristiques pour s'y retrouver.
Ce qui veut dire que son travail n'est pas parfait et qu'il peut faire des erreurs.

Ensuite, tu as le véritable compilateur qui fait une compilation complète du code.

Sur les génériques, tu as un problème assez simple : Le générique est en réalité un patron qui dit au compilateur de créer un nouveau type, en remplaçant le type joker, par le type réel. Si tu déclares deux listes génériques avec des types différents, le compilateur génèrera deux types listes bien dissociés.
En revanche, le compilateur Kibitz ne travaille que sur la syntaxe. Il n'est pas capable d'identifier le type réel dans la liste.

Hum, très bien. C'est juste un peu "génant" de voir ces erreurs alors que le code est bon. Mais bon, tant que c'est que ça, ça va.

Merci bien pour ton explication Franck.

[LadyWasky]

Coucou,

petit passage éclair pour vous dire que je dois avoir plusieurs listings de code sur le forum comme exemples de classes dérivées de TObjectList, avec différentes implémentations de IndexOf.

ça peut être utile.


bises,
Chloé

[ero-sennin]

Salut Chloé

Je ferai une petite recherche voir si je retrouve un de tes posts à ce sujet...
Je me pencherai dessus dès que j'aurai un peu plus de temps

Merci

[LadyWasky]

Dans les codes sources de mes défi aussi, il y en a quelques uns, et plus récemment, là :
http://www.developpez.net/forums/d23...freeware-d7pe/


Extrait de code :

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
unit UnitPlanning;
 
interface
uses
  Sysutils, Classes,Graphics,Contnrs;
type
  TFiche=class
  ...
  public
     constructor Create;
     destructor Destroy; override;
     function isBetween(DateHeureDebut,DateHeureFin:TDateTime):boolean;
     Property Debut : TDateTime read FDebut write SetDebut;
     property Fin : TDateTime read FFin write SetFin;
     property Titre : string read FTitre write SetTitre;
     property Description : TStringList read FDescription write SetDescription;
     property Tag1:integer read FTag1 write SetTag1;
     property Tag2:integer read FTag2 write SetTag2;
     property BkgColor:TColor read FBkgColor write SetBkgColor;
     property Visible:Boolean read FVisible write SetVisible;
  end;
 
TPlanning = class
private
    FList: TObjectList;
    FIsEditing: boolean;
    FFicheCourante: TFiche;
    FIndexCourant: Integer;
    FOnEditingChange: TNotifyEvent;
    FOnBrowse: TNotifyEvent;
    FFileName:string;
    function GetItem(Index: Integer): TFiche;
    function GetCapacity: Integer;
    function GetCount: Integer;
    procedure SetItem(Index: Integer; const Value: TFiche);
    procedure SetCapacity(const Value: Integer);
    procedure SetCount(const Value: Integer);
    function GetOwnsObjects: boolean;
    procedure SetOwnsObjects(const Value: boolean);
    procedure SetIndexCourant(const Value: Integer);
    procedure SetIsEditing(const Value: boolean);
    procedure SetOnBrowse(const Value: TNotifyEvent);
    procedure SetOnEditingChange(const Value: TNotifyEvent);
    procedure UpdateFicheCourante;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(Item: TFiche): Integer;
    procedure Clear; virtual;
    procedure Delete(Index: Integer);
    procedure Exchange(Index1, Index2: Integer);
    function Expand: TPlanning;
    function Extract(Item: TFiche): TFiche;
    function First: TFiche;
    function IndexOf(Item: TFiche): Integer; overload;
    function IndexOf(DateHeureCherchee:TDateTime): integer; overload;
    procedure Insert(Index: Integer; Item: TFiche);
    function Last: TFiche;
    procedure Move(CurIndex, NewIndex: Integer);
    function Remove(Item: TFiche): Integer;
    procedure Pack;
    procedure Sort(Compare: TListSortCompare);
    procedure Assign(ListA: TPlanning; AOperator: TListAssignOp = laCopy; ListB: TPlanning = nil);
    property Capacity: Integer read GetCapacity write SetCapacity;
    property Count: Integer read GetCount write SetCount;
    property Items[Index: Integer]: TFiche read GetItem write SetItem; default;
    property OwnsObjects: boolean read GetOwnsObjects write SetOwnsObjects;
    procedure LoadFromFile(const FileName: string);
    procedure LoadFromStream(Stream: TStream);
    procedure SaveToFile(const FileName: string);
    procedure SaveToStream(Stream: TStream);
    procedure Save;
    property IndexCourant:Integer read FIndexCourant write SetIndexCourant;
    property IsEditing:boolean read FIsEditing write SetIsEditing;
    property FicheCourante:TFiche read FFicheCourante;
    property OnEditingChange:TNotifyEvent read FOnEditingChange write SetOnEditingChange;
    property OnBrowse:TNotifyEvent read FOnBrowse write SetOnBrowse;
  end;
 
implementation
uses UnitStreams, DateUtils;
{ TFiche }
...
{ TPlanning }
 
function TPlanning.IndexOf(Item: TFiche): Integer;
begin
  Result := FList.IndexOf(Item);
end;
 
 
function TPlanning.IndexOf(DateHeureCherchee: TDateTime): integer;
var i:integer;
    trouve:Boolean;
    UneFiche:TFiche;
begin
  result:=-1;
  trouve:=False;
  if Count=0 then Exit;
 
  i:=0;
  while ((i<Count) and (not trouve)) do
  begin
    UneFiche:=Items[i];
    if ((UneFiche.FDebut<=DateHeureCherchee) and (UneFiche.FFin>=DateHeureCherchee))
    then begin
           trouve:=true;
           result:=i;
         end;
    inc(i);
  end;
end;
 
end.

Vous voyez qu'en fait, le IndexOf du TObjectList, par convention, sert à chercher un objet précis, une instance de classe en fait (une TFiche dans ce cas).
Mais on peut aussi très bien surcharger cette méthode pour faire une recherche permettant de trouver un objet de la liste correspondant à certains critères, dans ce cas, le code correspond à une recherche dans une liste avec moultes comparaisons sur les propriétés de chacun de ses élément, comme une recherche dans un tableau (plus ou moins), ou la recherche d'une ligne particulière dans un TStringList

Bon, ici, je ne crée pas un descendant direct de TObjectList (La liste est plutôt une variable privée de la classe).

Tout comme ici :
http://www.developpez.net/forums/d97...e/#post5466932


Si je fais comme ça, c'est que c'est moins casse-pied à écrire qu'un héritage direct de TObjectList (ouah l'autre hé !... )

Mais, sinon, pour un héritage direct, voici un autre exemple :
http://www.developpez.net/forums/d11...b-tobjectlist/


bon courage !

[ero-sennin]

Oh! J'en demandé pas tant.
C'est très gentil de ta part de m'avoir trouvé les posts intéressants.
(Bon, ba je vais être obligé de les regarder maintenant ).

Une fois de plus, merci

[LadyWasky]

Ha oui, sinon, le truc auquel il faut toujours penser et faire très très attention, mais tu dois le savoir, c'est la propriété OwnsObject

Si elle est à True, lors de la destructuin du TObjectList avec un free, pouf !, y'a plus d'objets dans la liste, ils sont tous détruits.

Si elle est à false, les objets qui étaient liés à la TObjectList restent tous en mémoire et ne sont pas détruits. (et là attention aux fuites mémoire !)

C'est parce qu'en fait, on peut définir une liste propriétaire qui recense tous les objets créés, et qu'a côté de ça on utilise des listes où on déplace les objets entre elles.

Les listes "de travail", une fois détruites, n'ont pas à détruire les objets qui leurs étaient liés, c'est le rôle de la liste de "recensement". A ce propos, vu sous cette angle, il faut bien faire attention :
- a ce que ce soit la liste de "recensement" qui soit détruite en dernier, sinon, il y aura des "trous et des "Access Violation" lors de l'accès aux listes de travail.
- a ne pas avoir un objet recensé dans 2 listes dont la propriété OwnsObject est à True...

C'est aussi l'idée qui se cache derrière le IndexOf qui recherche un instance de classe particulière. On peut avoir par besoin, à partir d'un objet sélectionné dans une liste, de connaître son existence dans l'autre liste.

C'est pas compliqué quand on le sait, mais ça peut être problématique quand on y fait pas attention