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

Soyez le premier à donner votre avis sur cette source.

Vue 6 349 fois - Téléchargée 233 fois

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+.

Codes Sources

A voir également

Ajouter un commentaire

Commentaire

cs_grandvizir
Messages postés
1237
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
10 -
Dans certaines fonctions de System.pas, il existe des syntaxes du type suivant (par analogie bien sûr):
function VarTypeIs(var Value):string;

Ainsi, Value peut non seulement être un type, mais aussi une classe, un objet...

N'y aurait-il pas ici une autre possibilité de code source ??

Précision que System raffole de l'ASM...

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.