Déterminer le type d'une variable à l'exécution

Télécharger le projet
Commenter

Description

Suite à une question posée sur le forum, il semble que nous ne disposions pas de fonction toute faite pour déterminer le type d'une variable à l'exécution.
Je ne sais pas si ce sera d'une grande utilité étant donné que le Pascal est un langage fortement typé.
Néanmoins, voici une réponse simple sous la forme d'une fonction nommée VarTypeIs.

Source / Exemple : 


function VarTypeIs(const Value: variant):String;
begin
  Result := 'Inconnu';
  case VarType(Value) of
    varEmpty	: Result := 'Vide'; //Le variant est non affecté (Unassigned).
    varNull	: Result := 'nul'; //Le variant est vide (Null).
    varSmallint	: Result := 'SmallInt'; //Entier signé sur 16 bits (type Smallint).
    varInteger	: Result := 'Integer'; //Entier signé sur 32 bits (type Integer).
    varSingle	: Result := 'Single'; //Valeur à virgule flottante à simple précision (type Single).
    varDouble	: Result := 'Double'; //Valeur à virgule flottante à double précision (type Double).
    varCurrency	: Result := 'Currency'; //Valeur à virgule flottante monétaire (type Currency).
    varDate	: Result := 'Date'; //Valeur date et heure (type TDateTime).
    varOleStr	: Result := 'OleStr'; //Référence à une chaîne Unicode allouée dynamiquement.
    varDispatch	: Result := 'IDispatch'; //Référence à un objet Automation (un pointeur d'interface IDispatch).
    varError	: Result := 'erreur du système'; //Code d'erreur du système d'exploitation.
    varBoolean	: Result := 'booleén 16 bits'; //Booléen sur 16 bits (type WordBool).
    varVariant	: Result := 'variant'; //Un variant.
    varUnknown	: Result := 'IUnknown'; //Référence à un objet OLE inconnu (un pointeur d'interface IUnknown ou IInterface).
    varShortInt	: Result := 'Entier signé sur 8 bits'; //Entier signé sur 8 bits (type ShortInt).
    varByte	: Result := 'byte'; //Un octet.
    varWord	: Result := 'word'; //16 bits non signé (Word)
    varLongWord	: Result := 'LongWord'; //32 bits non signé (LongWord)
    varInt64	: Result := 'Int64'; //Entier signé sur 64 bits (type Int64)
    varStrArg	: Result := 'Chaîne compatible COM'; //Chaîne compatible COM.
    varString	: Result := 'String'; //Référence de chaîne allouée dynamiquement (non compatible COM).
    varAny	: Result := 'Toute valeur CORBA'; //Toute valeur CORBA.
  end;
end;

//Exemple d'utilisation :
procedure TForm1.Button1Click(Sender: TObject);
var
  V : variant; // <- se verra affecté n'importe quoi
  i: integer;
  C: char;
  S: string;
begin
  i:= 5;
  V := i;
  ShowMessageFmt('i est du type %s', [VarTypeIs(v)]);
  C := 'A';
  V:= C;
  ShowMessageFmt('C est du type %s', [VarTypeIs(v)]);
  S := 'Hello world !';
  V := S;
  ShowMessageFmt('S est du type %s', [VarTypeIs(v)]);
end;

Conclusion :


Ici on se sert d'une des caractéristiques intéressantes du type variant, à savoir pouvoir lui affecter à peu près n'importe quoi.
Si ça peut servir à au moins une personne...

Compatible Delphi 2+.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_Delphiprog)