Discussion :

[NotANumber]

Boujour j'ai déja posté ce message sur le forum Delphi.Net mais quelqu'un pourra peut etre m'aider ici !

http://www.developpez.net/forums/viewtopic.php?t=421110

[anapurna]

salut

argh j'ai mis la reponse dans delphi.net
je ne suis pas sur pour le net parcontre pour win32
c'est certain

il faut que tu transtype ton element de sortie

Code :

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

1
2
3
4
5
function TListFlux.Get(Index: Integer): TFlux;
begin
  Result := inherited Get(Index) as TFlux; 
//la fontion inherithed get te genere un Tobject
end;

@+ Phil

[NotANumber]

Ca marche impécable ! Je te remercie !

[e-ric]

Salut

Je vais jouer le rabat-joie, la solution marche peut-être mais elle n'est pas très propre car elle revient à modifier la signature des méthodes d'origine.

Ce genre d'héritage n'est pas proprement supporté par Delphi, malheureusement (il s'agit de la covariance si je me souviens bien).

A mon sens, une meilleure solution aurait consisté à créer une classe TListFlux non dérivée de TList mais utilisant une TList en interne.

Enfin, l'emploi de la directive Reintroduce n'est-elle pas une piste plus sûre (à toi de voir, je n'ai pas creusé le sujet).

qu'en pensez-vous ?

cdlt

e-ric

[NotANumber]

Oui mais dans ce cas y a un pb de type car si je ne l'hérite pas il attendra un TObjet et pas un TFlux dans le TList.

[e-ric]

Normalement cela ne pose pas de problème car le type retourné TFlux est un descendant de TObject, la conversion de type est implicite (à vérifier tout de même). La conversion dasn l'utre sens (de TFlux vers TObject ) est plus discutable et nécesssite un cast (pas beau).

En outre, dans la première solution, je proposais de réécrire un container à la manière de TList mais sans dériver cette dernière classe, tu peux alors définir les signatures que tu désires sans difficulté particulière.

PS : je n'ai pas encore étudié D8 donc je ne connais pas les nouvelles caractéristiques du langage.

cdlt

e-ric

[veloce]

Normalement cela ne pose pas de problème car le type retourné TFlux est un descendant de TObject, la conversion de type est implicite (à vérifier tout de même). La conversion dasn l'utre sens (de TFlux vers TObject ) est plus discutable et nécesssite un cast (pas beau).

J'aurais dit le contraire : de TFlux à TObject : cast explicite, mais il faut faire le cast pour 'dire' au compilo de considérer qu'un TObject est un TFlux

[e-ric]

Salut à tous

Voilà pour préciser mes idées (j'ai repris et adapté le code original) :

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
 
unit MesClasses;
 
interface
 
uses
   Classes;
 
type
 
  TFlux = class(TObject)
  private
    FFlux, FURL: String;
  public
    property Flux: String read FFlux;
    property URL: String read FURL;
  end;
 
  TListFlux = class(TList)
  private
    FList: TList;
    function GetCount: Integer;
    function GetItems(Index: Integer): TFLux;
    procedure SetItems(Index: Integer; const Value: TFLux);
  protected
  public
    constructor Create;
    destructor Destroy; override;
    function Add(Item: TFlux): Integer;
    property Count: Integer read GetCount;
    property Items[Index: Integer]: TFLux read GetItems write SetItems; default;
  end;
 
implementation
 
//METHODES POUR TListFlux
 
function TListFlux.Add(Item: TFlux): Integer;
begin
  Result := FList.Add(Item);
end;
 
constructor TListFlux.Create;
begin
  FList := Tlist.Create;
end;
 
destructor TListFlux.Destroy;
begin
  FList.Free;
  inherited;
end;
 
function TListFlux.GetCount: Integer;
begin
  Result := FList.Count;
end;
 
function TListFlux.GetItems(Index: Integer): TFLux;
begin
  // la conversion est IMPLICITE car TFlux descend de TObject
  // la spécification du type de retour suffirt pour le conversion
  Result := FList[Index];
end;
 
procedure TListFlux.SetItems(Index: Integer; const Value: TFLux);
begin
  FList[Index] := Value;
end;
 
end.

J'ai utilisé une TList en interne (bref une composition) et non pas un héritage, le code est tout aussi clair et ne "maltraite" pas le compilateur ni le développeur chargé de la maintenance. Votre avis ???

Voili voilà ...

cdlt

e-ric

[anapurna]

salut

je ne voit plus la necessite de faire

Code :

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

1
2
 
 TListFlux = class(TList)

quand aux cast il ne pose aucun probleme on ne maltraite pas le
compilateur de plus vu que les donnée enregistrer dans la tlist ne sont que des pointeur (adresse dans une table memmoire)
deguisé si en entrée tu force a mettre un element de type tflux
en sortie tu retrouve forcement le meme elements le cast n'est la que pour reafirmer son type

function TListFlux.GetItems(Index: Integer): TFLux;
begin
// la conversion est IMPLICITE car TFlux descend de TObject
// la spécification du type de retour suffirt pour le conversion
Result := FList[Index];
end;

procedure TListFlux.SetItems(Index: Integer; const Value: TFLux);
begin
FList[Index] := Value;
end;

je ne suis pas du tout sur que cela marche
la list genere un tobject est pas un tflux
le result ne cast pas ton element donc il retournera un tobject


pour info celui ci n'est pas transformer en cour d'utilisation
mais bon a chacun sa philosophie

@+ Phil

[e-ric]

je ne voit plus la necessite de faire

Code :

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

1
2
 
 TListFlux = class(TList)

Effectivement, j'ai gaffé, j'ai oublié de supprimé cet héritage, sorry !!

quand aux cast il ne pose aucun probleme on ne maltraite pas le
compilateur de plus vu que les donnée enregistrer dans la tlist ne sont que des pointeur (adresse dans une table memmoire)
deguisé si en entrée tu force a mettre un element de type tflux
en sortie tu retrouve forcement le meme elements le cast n'est la que pour reafirmer son type

function TListFlux.GetItems(Index: Integer): TFLux;
begin
// la conversion est IMPLICITE car TFlux descend de TObject
// la spécification du type de retour suffirt pour le conversion
Result := FList[Index];
end;

procedure TListFlux.SetItems(Index: Integer; const Value: TFLux);
begin
FList[Index] := Value;
end;

je ne suis pas du tout sur que cela marche

On prend les paris ? Reprend le code et teste !
En outre, je pense que l'usage intempestif de cast nuit à la qualité du code et à sa lisibilité.

la list genere un tobject est pas un tflux
le result ne cast pas ton element donc il retournera un tobject

Ce n'est pas la liste qui génère les les objets contenus, ils sont affectés par un appel à SetItems, le contrôle de type des méthodes SetItems et Add empêche donc d'affecter autre chose que des TFlux dans la liste, son contenu reste ainsi cohérent en terme de type. Il n'y a pas de transformation de type à l'appel du Getter mais cela est nécessaire pour la définition de la propriété (identité de type en lecture et en écriture).

La formulation du code que je propose ne pose aucun problème, les cast ne sont pas absolument pas nécessaires.

pour info celui ci n'est pas transformer en cour d'utilisation
mais bon a chacun sa philosophie
@+ Phil

cdlt

e-ric

[anapurna]

salut

je rprend la parti du code d'origine
su ce point j'espere que tu est d'accord avec moi on force
a entrer un TFlux dans la liste herite on reecrit donc sur la methode
existante et ensuite on font appel a la mecanique du tlist ancetre

Code :

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

1
2
3
4
5
 
function TListFlux.Add(Item: TFlux): Integer;
begin
  Result := inherited Add(Item);
end;

je reprend ton code ce que tu fait revient
a peut pres a la meme chose sauf que tu n'utilise pas l'heritage
mais tu affecte un objet dans la tlist

Code :

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

1
2
3
4
procedure TListFlux.SetItems(Index: Integer; const Value: TFLux);
begin
FList[Index] := Value;
end;

je reprend donc le code du tlist

Code :

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

1
2
3
4
5
6
function TList.Add(Item: Pointer): Integer;
begin
  ...
  FList^[Result] := Item;
  ...
end;

c'est bien un pointer que tu enregistre dans la tlist

quand au get on regarde de nouveau la tlist

Code :

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

1
2
3
4
5
function TList.Get(Index: Integer): Pointer;
begin
  ...
  Result := FList^[Index];
end;

c'est bien un pointer que tu rend

il n'y a aucune modification et verification de type dans la liste entre
l'entrer et la sortie

donc meme si tu ne le cast pas explicitement il se cast de toutes les
façon

je ne sais pas si le cast inplicite marche
je testerai ce soir ta version
mais moi je prefere de loin savoir ce que je fait plutot que de laisser le compilateur choisir a ma place

bon j'ai verifier ton code ca marche pas mal
mais voila j'ai ete curieux et j'ai regarder comment ete fait le tobjectlist ou le tclasslist et c'est des derive de tlist
y'a qua regarder le code et adapter au flux
ce qui nous donne

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
 TLstFlux = class(Tlist)
  protected
    function GetItems(Index: Integer): TFLux;
    procedure SetItems(Index: Integer; AFLux: TFLux);
  public
    function Add(AFLux : TFLux): Integer;
    function Extract(Item: TFLux): TFLux;
    function Remove(AFLux: TFLux): Integer;
    function IndexOf(AFLux: TFLux): Integer;
    function First : TFLux;
    function Last  : TFLux;
    procedure Insert(Index: Integer; AFLux: TFLux);
    property Items[Index: Integer]: TFLux read GetItems write SetItems; default;
  end;
 
implementation
 
{ TClassList }
function TLstFlux.Add(AFlux: TFlux): Integer;
begin
  Result := inherited Add(AFlux);
end;
 
function TLstFlux.Extract(Item: TFlux): TFlux;
begin
  Result := TFlux(inherited Extract(Item));
end;
 
function TLstFlux.First: TFlux;
begin
  Result := TFlux(inherited First);
end;
 
function TLstFlux.GetItems(Index: Integer): TFlux;
begin
  Result := TFlux(inherited Items[Index]);
end;
 
function TLstFlux.IndexOf(AFlux: TFlux): Integer;
begin
  Result := inherited IndexOf(AFlux);
end;
 
procedure TLstFlux.Insert(Index: Integer; AFlux: TFlux);
begin
  inherited Insert(Index, AFlux);
end;
 
function TLstFlux.Last: TFlux;
begin
  Result := TFlux(inherited Last);
end;
 
function TLstFlux.Remove(AFlux: TFlux): Integer;
begin
  Result := inherited Remove(AFlux);
end;
 
procedure TLstFlux.SetItems(Index: Integer; AFlux: TFlux);
begin
  inherited Items[Index] := AFlux;
end;

@+ Phil