Discussion :

[WebPac]

Bonjour tout le monde.

Chaque fois que je définis un composant (TMyComponent), je définis une liste associée (TMyList) qui permet de gérer des TMyComponent sans avoir à transtyper à chaque fois des items.
Pour faire ainsi, je fais ce 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
  TMyList = class( TList )
  protected
    function GetItem( Index : Integer ) : TMyComponent;
    procedure SetItem( Index : Integer; const Value : TMyComponent );
 
  public
    property Items[ Index : Integer ] : TMyComponent read GetItem write SetItem; default;
  end;
 
// ....
function TMyList.GetItem( Index : Integer ) : TMyComponent;
begin
  Result := inherited Items[ Index ] as TMyComponent
end;
 
procedure TMyList.SetItem( Index : Integer; const Value : TMyComponent );
begin
  inherited Items[ Index ] := Value;
end;

Mon soucis est que lorsque je vais dériver le composant (TMyDerivedComponent) et que je désire faire sa liste associée, je suis obligé de redéfinir les méthodes GetItem et SetItem.
Sans parler des autres méthodes, qu'il faut surcharger juste pour qu'elles retournent les nouveaux types afin de ne pas transtyper les composants dans le code.

Je suis sûr qu'il existe un moyen plus simple mais je n'ai pas encore trouvé comment. Avez-vous une idée ?

Merci.

[Graffito]

Bonjour,

L'implementation de ta property est tout à fait logique (bonne programmation à conseiller à tous).

Malheureseument, je crois qu'il ny a pas vraiment de methode qui puisse te faciliter la vie pour les classes dérivées.
Ce serait contraire à la philsophie générale des types et des héritages.

[WebPac]

Je comprends, donc lorsque je désire faire une TMyFilleList dérivée de TMyList, je dois redéfinir toutes les méthodes qui retournent un TmrComponent en faisant par exemple :

Code :

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

1
2
3
4
function TMyFilleList.GetByNom( aNom : string ) : TMyNewComponent;
begin
  Result := inherited GetByNom( aNom ) as TMyNewComponent;
end;

C'est un moindre mal.
Mais je me demande si niveau optimisation, si c'est judicieux car si j'encapsule plusieurs classes dérivées, cela va entrainer un certain nombre de transtypage, et si je me souviens bien, il est conseillé de ne pas trop en faire.

[edam]

tu veux vraiment cassé ta tête, regarde dans le source de delphi comment, pour qu'il enregistre les composants ajouté dans un conteneur comme une forme, (si je comprend bien ce que tu veux )

[WebPac]

En fait, j'ai pas très bien compris ce que tu me conseilles de faire.
Une TList est une liste de pointeurs, donc non typés. Il faut typer l'élément d'une TList pour pouvoir utiliser des méthodes de l'objet.
En typant directement les items de la TMyList, je peux directement utiliser les méthodes sans faire de typage, c'est plus facile pour coder.

[edam]

désoler tu peut expliqué plus
utlisé les méthode de qoi??

[sjrd]

Récemment vu sur le forum, voir l'outil que propose waskol :
http://www.developpez.net/forums/viewtopic.php?t=474390

[WebPac]

Une méthode est une procédure ou fonction associée à une classe.

Imagines, tu as déclaré un composant, TMyComponent, ayant comme méthode :

Code :

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

procedure ShowDescription;

Quand tu as une liste qui définie ses Items comme étant des TMyComponent, il suffit de faire :

Code :

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

MyList[ i ].ShowDescription;

et non

Code :

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

 ( List[ i ] as TMyComponent ).ShowDescription;

Imagines tu as une liste TMyList de TMyComponent possédant une méthode GetByNom qui retourne un TMyComponent, si tu définies une classe fille TMyFilleList de TMyList de TMyFilleComponent, il faudra redéfinir la méthode pour qu'elle retourne des TMyFilleComponent et non des TMyComponent

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
  TMyList = class( TList )
  // ...
  public
    function GetByName( aName : string ) : TMyComponent;
  end;
 
  TMyFilleList = class( TMyList )
  // ...
  public
    function GetByName( aName : string ) : TMyFilleComponent;
  end;

Et le code de la dernière méthode de fait qu'un inherited avec le résultat transtypé en TMyFilleComponent (comme indiqué plus haut dans le topic).
C'est un peu du code qui ne sert pas à grand chose, j'aimerais bien trouver une solution pour ne pas avoir à redéfinir l'ensemble des méthodes des classes filles, car ic je donne un exemple simple avec une seule classe fille et une seule méthode à surcharger, mais dans mon code, il doit y avoir 10 ou 20 classes avec je ne sais pas trop combien de méthodes.

[WebPac]

Salut Sjrd, je viens de lire le sujet que tu as mis en lien, mais à moins que je n'ai pas suivi, ce n'est pas le même problème.
Je ne souhaites pas à réimplémenter des classes Listes personnalisées à partir d'un TObject et avoir à refaire l'ensemble des méthodes d'une TList.
Je souhaite pouvoir créer des classes dérivées d'une TList afin de pouvoir réutiliser les méthodes d'une TList sans avoir à les refaire, et pouvoir typer la valeur de retour de la liste et ne pas avoir à redéfinir l'ensemble des méthodes des listes personnalisées.

Je viens de voir le programme de Waskol, mais il permet juste d'automatiser la déclaration et l'implémentation des fonctions de base de la liste personnalisée, cela ne répond pas à mon problème.

Je ne sais pas si je suis clair dans mes propos en fait.

[sjrd]

J'avais bien compris... Mais tu ne pourras pas faire mieux en Pascal & Co. Il faudrait disposer des templates de C++ pour pouvoir faire mieux. Mais d'ici que les templates soient supportées en Delphi...

[WebPac]

Oui, c'est bien ce que je me disais. J'espérais qu'il existe un autre moyen.
Tant pis, je vais rester comme je fais actuellement.

[Graffito]

Bonjour,

J'utilise assez courament ce genre de transtypage en cascade dans des classes dérivées (et delphi l'utilise plus encore dans les bibli) , j'ai jamais rencontré de problème à ce sujet.

[WebPac]

Pour l'instant moi non plus, mais j'ai entendu dire que trop transtyper pouvait ralentir l'exécution de l'application, car l'application doit rechercher dans la hiérarchie des classes laquelle implémente la fonction appellée.
Enfin finallement, je crois que je confonds avec les méthodes virtuelles.

[Laurent Dardenne]

Enfin finallement, je crois que je confonds avec les méthodes virtuelles.

Non les opérateur AS et IS s'appuie sur les RTTI à la différence du transtypage à la compilation.

[WebPac]

Non les opérateur AS et IS s'appuie sur les RTTI à la différence du transtypage à la compilation.

Donc cela confirme qu'il est conseillé de ne pas mettre des transtypages en cascade ?

[Graffito]

Bonjour,

J'utilise for peu les 'as', et au lieu

deResult := inherited GetByNom( aNom ) as TMyNewComponent;

et j'aurais plutot écrit

Code :

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

Result := TMyNewComponent(inherited GetByNom( aNom )) ;

Le résultat est équivalent, mais je ne m'étais jamais posé la question de savoir si c'était compilé différement, ce qui est effectivement très possible.

[Laurent Dardenne]

Donc cela confirme qu'il est conseillé de ne pas mettre des transtypages en cascade ?

Je n'irais pas jusque là.
D'après ton exemple les éléments de tes listes contiennent tjr le même type d'élément (est-ce tjr le cas dans ton appli ?), l'utilisation de l'opérateur AS n'est pas nécessaire dans ce cas.
[Edit]
Trop lent pour répondre

[WebPac]

Graffito, je ne sais pas non plus si c'est compilé différement ni si l'une est conseillée par rapport à l'autre, c'est marrant, je n'utilise jamais ta méthode et toujours avec AS. Question de gout.

Laurent, en général, j'aime bien créer un type de liste pour chaque type d'objet que j'ai. Ainsi, il existe des objets qui ont des descendants (du point de vue héritage) jusqu'à 3 génération, d'autres aucun, et des classes "mères", il y doit y en avoir une bonne vingtaine, avec un majorité d'entre eux, j'ai besoin de certaines méthodes du style GetByNom.
C'était pour arriver à créer de nouvelles classes avec les classes List associées sans avoir à redéfinir les méthodes, et dans un second temps savoir ce qui est le plus optimisé.

Mais comme l'a dit Sjrd, sans les templates, je doute qu'on puisse faire mieux.

[sjrd]

Une petite précision : le transtypage ne doit pas être confondu avec l'opérateur as. L'opérateur as, c'est l'opérateur is + transtypage si True ou génération d'exception si False.
En fait, ceci :

Code :

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

ClasseEnfant := ClasseParent as TClasseEnfant;

correspond à ça :

Code :

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

1
2
3
4
if ClasseParent is TClasseEnfant then
  ClasseEnfant := TClasseEnfant(ClasseParent)
else
  ECastError.Create(ClasseParent.ClassName + ' n''est pas un descendant de '+TClasseEnfant.ClassName);

Autrement dit, lorsque vous savez que ClasseParent est bel et bien une instance de TClasseEnfant, utilisez le transtypage. Si vous devez vérifier que c'est bien le cas, utilisez soit l'opérateur is et un transtypage ou l'opérateur as.

Finalement, j'ajouterai que l'opérateur as ne peut être utilisé qu'avec des classes et uniquement si ClasseParent est déclarée comme une classe dans la généalogie directe de TClasseEnfant. Par généalogie directe, j'entends les parents, grands-parents, enfants, petits-enfants etc. Mais pas les cousins ou les oncles par exemple
En revanche, le transtypage peut être utilisé avec n'importe quels types, du moment qu'ils sont stockés sur le même nombre d'octets. Ainsi, n'importe quel TObject peut être transtypé en integer et vice versa ; par contre, un TObject ne peut être transtypé en Byte.
Notez bien qu'il possible de "transtyper" un integer en un Byte, alors qu'ils ne sont pas stockés sur le même nombre d'octets. En fait, ce n'est pas un réel transtypage : les transtypages entre types nombres, de même que les transtypages entre types chaînes, sont compilés spécialement de façon à effectuer une véritable conversion de format.

[WebPac]

Merci Sjrd pour ces précisions, je suis vraiment content d'apprendre comment marche l'opérateur as.
Du coup je sais plus si je vais garder les as ou utiliser des transtypages.