Comment passer un nombre variable de paramètres à une procédure ?

procedure ParametreVariant(AValeur:Variant);
begin
  WriteLn('Un seul element du type ',VarTypeAsText(VarType(Variant(AValeur))),
          ' sa valeur est ' ,Variant(AValeur));
end;

ParametreVariant('Une chaine');
 ParametreVariant(3.14159);
 ParametreVariant(True);

Un seul element du type String sa valeur est Une chaine
Un seul element du type Double sa valeur est 3,14159
Un seul element du type Boolean sa valeur est True

procedure ParametreVariant(AValeur:Variant);
var I           : Integer;
    LimiteHaute,
    LimiteBasse : Integer;
    
begin
 if VarIsArray(AValeur) then 
 begin
   LimiteHaute := VarArrayHighBound(AValeur, 1);
   LimiteBasse := VarArrayLowBound(AValeur, 1);
   for I := LimiteBasse to LimiteHaute do
    WriteLn('L''element ', I,
            ' est du type ',VarTypeAsText(VarType(Variant(AValeur[i]))),
            ' sa valeur est ' ,Variant(AValeur[i]));
   ReadLn;
  end
  else
  begin
    WriteLn('Un seul element du type ',VarTypeAsText(VarType(Variant(AValeur))),
            ' sa valeur est ' ,Variant(AValeur));
  end;
end;

For MaVariable in [Objet1,Objet2,Objetn] do

{$ASSERTIONS ON}
type
 TMaClasse=class
 end;

 TMaClasseDynArray  = array of TMaClasse;

Function MakeArray(Args: Array of const) :TMaClasseDynArray;
//Construit un tableau d'un type spécifique
Var I: Integer;
    Count : Integer;
begin
 Count:=High(Args);
 Assert(Count>0,'Tableau vide non supporté.');
 SetLength(Result,Count+1);
 for I := 0 to High(Args) do
 with Args[i] do
  case VType of
        vtObject: Result[i]:= TMaClasse(VObject); //Implique un tanstypage pour chaque type de tableau manipulé
   else Assert(1<>1,'Type non supporté.');
  end;//Case
end;

begin
 Obj1:=TMaClasse.Create;
 Obj2:=TMaClasse.Create;
 Obj3:=TMaClasse.Create;
 try
   TabDynamique:=MakeArray([Obj1,Obj2,Obj3]);

   for Current in TabDynamique do
    Writeln(Current.ClassName);
    // Delphi 7 et <
    //Current : TObject
    //Writeln(TMaClasse(Current).ClassName);
  Finally
   Obj1.Free;
   Obj2.Free;
   Obj3.Free;

   Finalize(TabDynamique); 
  end;
end.

TVarRecDynArray= Array of TVarRec;
 ...
 Function MakeArray(Args: Array of const) : TVarRecDynArray;

var ArrayVarRec : TVarRecDynArray;
    Current : TVarRec;
...
 Try
   Try
    ArrayVarRec:=MakeArray([TObject.Create,TForm.Create(Nil),TLabel.Create(Nil) ]);
    for Current in ArrayVarRec do
     Writeln(TObject(Current.VObject).ClassName);
   except
    On EAssertionFailed do Writeln('Erreur d''assertion.');
   end;
  Finally
   FreeAndFinalize(ArrayVarRec);
  end;

 ArrayVarRec:=MakeArray([TObject.Create,TForm.Create(Nil),TLabel.Create(Nil) ]);
 Writeln(TObject(Current.VObject).ClassName);

procedure FreeAndFinalize(AArray : TVarRecDynArray);
Var Current : TVarRec;
    Objet: TObject;
begin
 For Current In AArray Do
  begin
   Objet:=TObject(Current.VObject);
   FreeAndNil(Objet);
  end;
 Finalize(AArray);
end;

function FonctionRetournantPlusieursTypes(const TypeParm: integer): Variant;
begin
  case TypeParm of
    1:  Result := -1;
    2:  Result := 3.5;
    3:  Result := 'UneChaîne';
    4:  Result := StrToDate('04/08/2007');
  end;
end;

Les routines surchargées doivent pouvoir se distinguer par le nombre ou le type de leurs paramètres.

program FonctionVariable1;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils,
  Classes;
 
function Appel(Cas:Integer) : TVarRec;
var
  Termine  : Boolean;
  Longueur : Integer;
  Liste    : TStringList;
begin
 Termine:=True;
 Longueur:=105;
 with Result do
  case Cas of
   0 : begin
        VType:=vtBoolean;
        VBoolean:=Termine;
       end;
   1 : begin
        VType:=vtInteger;
        VInteger:=Longueur;
       end;
   2 : begin
         VType:=vtObject;
         VObject:=TStringList.Create;
         TStrings(VObject).Add('Je suis une instance de TStrings');
       end;
   3 : begin
         VType:=vtClass;
         VClass:=TObject;
        end;
  end;
end;
 
procedure Traite(ValeurRetour :TVarRec);
Const S='Retour de fonction avec le type : %S ';
begin
  With ValeurRetour do
  Case VType of
    vtBoolean: Writeln(Format(S,['Boolean']),VBoolean);
    vtInteger:Writeln(Format(S,['Integer']),VInteger);
    vtObject:begin
              With TStrings(VObject) do
              begin
                Writeln(Format(S,['Objet']),TStringList(VObject)[0]);
                Free;
              end;
             end;
    vtClass:Writeln(Format(S,['Classe']),VClass.ClassName);
  end;
end;
 
var I:Integer;
begin
 For I:=0 to 3 do
 begin
  Traite(Appel(I));
 end;
 readln;
end.

function Appel(Args: Array of const) : TVarRec;
//Cette fonction n'effectue aucun traitement si ce n'est de renvoyer le paramètre reçu
Const S='Appel de fonction avec le type : %S ';
begin
 Assert(High(Args)<>1,'Une et une seule valeur attendue.');
 Writeln(Format(S,[cstNameOfVType[Args[0].VType]]));
 Result:=Args[0];
 {ou peut aussi construire le TVarrec à retourner
  with Result do
  case Data.VType of
   vtBoolean : begin
                VType:=vtBoolean;
                VBoolean:=Data.VBoolean;
               end;
   vtObject  : begin
                VType:=vtObject;
                VObject:=TStringList.Create;
                TStrings(Result.VObject).Add('Je suis une instance de TStrings')
              end;
   vtInteger : begin
   ...
  }
end;

  Variant = type TObject;
  OleVariant = type TObject;