Les génériques avec Delphi 2009 Win32

Il n'existe qu'un nombre restreint de contraintes possibles. En fait, il n'en existe que de trois types, dont un pour lequel je n'ai pas trouvé d'utilité :-s.

On peut donc restreindre un type générique à être :

• un type classe descendant d'une classe donnée ;
• un type interface descendant d'une interface donnée, ou un type classe implémentant cette interface ;
• un type ordinal, flottant ou record ;
• un type classe qui possède un constructeur sans argument.

Pour imposer une contrainte à un paramètre générique, on note :

type
  TStreamGenericType<T: TStream> = class
  end;

  TIntfListGenericType<T: IInterfaceList> = class
  end;

  TSimpleTypeGenericType<T: record> = class
  end;

  TConstructorGenericType<T: constructor> = class
  end;

Ce qui impose, respectivement, que T devra être remplacé par la classe TStream ou une de ses descendantes ; par IInterfaceList ou une de ses descendantes ; par un type ordinal, flottant ou record (un type de valeur non null, selon la terminologie de Delphi) ; ou enfin par un type classe qui possède un constructeur public sans argument.

Il est possible de combiner plusieurs contraintes interface, ou une contrainte classe et une à plusieurs contraintes interface. Dans ce cas, le type réel utilisé doit satisfaire toutes les contraintes en même temps. La contrainte constructor peut également être combinée avec des contraintes classe et/ou interface. Il est même possible de combiner record avec une ou plusieurs contraintes interface, mais je ne vois pas comment un type pourrait bien satisfaire les deux en même temps (en .NET, c'est possible, mais, pour l'instant, pas en Win32) !

On peut aussi utiliser une classe ou interface générique comme contrainte, avec donc un paramètre à spécifier. Ce paramètre peut être le type T lui-même. Par exemple, on peut vouloir imposer que le type d'éléments doive pouvoir se comparer avec lui-même. On utilisera alors :

type
  TSortedList<T: IComparable<T>> = class(TObject)
  end;

Si l'on veut en plus que T soit un type classe, on peut combiner :

type
  TSortedList<T: class, IComparable<T>> = class(TObject)
  end;

« Je croyais que le but des génériques était justement d'écrire une fois le code pour tous les types. Quel est alors l'intérêt de restreindre les types possibles ? »

Eh bien cela permet au compilateur d'avoir plus d'informations sur le type utilisé. Par exemple, cela lui permet de savoir, avec un type <T: class>, qu'il est légitime d'appeler la méthode Free dessus. Ou avec un type <T: IComparable<T>>, qu'il est possible d'écrire Left.CompareTo(Right).

Pour illustrer cela, nous allons créer une classe fille de TTreeNode<T>, TObjectTreeNode<T: class>. À l'instar de TObjectList<T: class> qui propose de libérer automatiquement ses éléments lorsque la liste est détruite, notre classe libérera sa valeur étiquetée lors de la destruction.

En fait, cela fait donc très peu de code, que je vais donner en une fois :

type
  {*
    Structure arborescente générique dont les valeurs sont des objets
    Lorsque le noeud est libéré, la valeur étiquetée est libérée également.
  *}
  TObjectTreeNode<T: class> = class(TTreeNode<T>)
  public
    destructor Destroy; override;
  end;

{--------------------}
{ TObjectTreeNode<T> }
{--------------------}

{*
  [@inheritDoc]
*}
destructor TObjectTreeNode<T>.Destroy;
begin
  Value.Free;
  inherited;
end;

Voilà, c'est tout. Le but est uniquement de montrer la technique. Pas d'avoir un truc exceptionnel.

Il y a deux choses à constater ici. D'abord, on peut faire hériter une classe générique d'une autre classe générique, en réutilisant le paramètre générique (ou pas, d'ailleurs).

Ensuite, dans l'implémentation des méthodes d'une classe générique avec contraintes, les contraintes ne doivent pas (et ne peuvent pas) être répétées.

Vous pouvez par ailleurs supprimer la contrainte et tenter de compiler. Le compilateur vous arrêtera sur l'appel à Free. En effet, Free n'est pas disponible sur n'importe quel type. Mais sur n'importe quelle classe, bien.

Vous pourriez aussi vouloir que les deux constructeurs sans paramètre AValue de TObjectTreeNode<T> créent un objet pour AValue au lieu d'utiliser Default(T) (qui, au passage, renvoie nil ici, car T est contraint à être une classe).

Vous pouvez, pour cela, utiliser la contrainte constructor, ce qui donne :

type
  {*
    Structure arborescente générique dont les valeurs sont des objets
    Lorsqu'un nœud est créé sans valeur étiquetée, une nouvelle valeur est
    créée avec le constructeur sans paramètre du type choisi.
    Lorsque le noeud est libéré, la valeur étiquetée est libérée également.
  *}
  TCreateObjectTreeNode<T: class, constructor> = class(TObjectTreeNode<T>)
  public
    constructor Create(AParent: TTreeNode<T>); overload;
    constructor Create; overload;
  end;

implementation

{*
  [@inheritDoc]
*}
constructor TCreateObjectTreeNode<T>.Create(AParent: TTreeNode<T>);
begin
  Create(AParent, T.Create);
end;

{*
  [@inheritDoc]
*}
constructor TCreateObjectTreeNode<T>.Create;
begin
  Create(T.Create);
end;

À nouveau, si vous retirez la contrainte constructor ici, le compilateur marquera une erreur sur le T.Create.