Delphi/Types

Une page de Wikiversité.
Aller à : navigation, rechercher
Début de la boite de navigation du chapitre
Types
Icône de la faculté
Chapitre no5
Leçon : Delphi
Chap. préc. : Variables et constantes
Chap. suiv. : Opérateurs
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Delphi : Types
Delphi/Types
 », n'a pu être restituée correctement ci-dessus.

Définition[modifier | modifier le wikitexte]

Tout d'abord, définissons un type.

En Delphi, comme en C, VB et contrairement au PHP, JavaScript, Python ou autre langage moderne, une variable est dites typée et ne peut contenir que des valeurs de ce type. En clair, un type est un attribut de la variable.

Types de base[modifier | modifier le wikitexte]

Delphi est extrêmement complet à ce niveau et il existe une multitude de types prédéfinis sans compter la possibilité de créer ses propres types (on verra ça plus tard). Voici un tableau contenant les types de base (ou types primitifs) les plus utiles:

Type Description Taille Valeur
boolean booléen 1 bit True/False (Vrai/Faux)
char caractère 1 octet un élément de la table ascii (ou ANSI)
string chaîne de caractères En fonction de sa taille tableau dynamique d'éléments de la table ascii (ou ANSI)
integer entier 4 octets signés -2147483648 à 2147483647
cardinal entier non signé 4 octets non signés 0 à 4294967295
real (double est équivalent) réel 8 octets 5.0 x 10^-324 à 1.7 x 10^308
Remarque : Ce sont les types prédéfinis les plus utilisés. Il en existe une dizaine d'autres rien que pour les entiers (smallint, longint, int64..) dont l'utilisation est adaptée pour ajuster de manière plus précise les tailles de variable aux données que l'on va y placer et ainsi optimiser l'utilisation de la mémoire. Pour plus d'information à ce sujet, vous pouvez vous documenter dans l'aide Delphi à ce sujet.

char[modifier | modifier le wikitexte]

Un char (caractère) est une donnée telle que '#', 'A', '2', ';', '.', '?' et ainsi de suite. Il est associé à un nombre dans la bibliothèque des caractère, la table ASCII. En Delphi, un char est écrit entre apostrophes. Si le caractère en question est aussi un apostrophe, alors il faut le doubler, ce qui donne au total quatre apostrophes à la suite.

var
  a, b: char;
 
begin
  a := 'H';  // a = "H"
  b := 'i';  // b = "i"
  WriteLn(a);  // Display "H"
  WriteLn(a, b);  // Display "Hi"
  WriteLn(a, b, '!');  // Display "Hi!"
end.

string[modifier | modifier le wikitexte]

Vous avez déjà travaillé avec des strings dans les chapitres précédents, tel que 'Hello World' ou 'Hi there' et ainsi de suite. Un string est une séquence de char.

 var
   texte1: string;
   caractere1: char;

Et ensuite écrivez entre begin et end:

 caractere1 := 'H';
 texte1 := 'ello World!';
 WriteLn(caractere1, texte1);

Si vous voulez écrire un apostrophe dans un string, doublez-le:

 texte1 := 'Je m''appelle Trucmuche.';

Les strings se comportent comme des tableaux. Vous pouvez accéder à un caractère par son index :

 texte := 'Hello World!';
 WriteLn(texte[1]); // Affiche uniquement "H".

Le premier indice est 1 (et non 0).

Entiers[modifier | modifier le wikitexte]

Les Integers sont des entiers, que l'on écrit comme suit :

 a: Integer;

Nombres décimaux[modifier | modifier le wikitexte]

Les nombres décimaux sont des nombres à virgule flottante, que l'on écrit comme suit :

 c: Real;   // Un Real est normalement la même chose qu'un Single
 a: Single;
 b: Double;
 d: Extended;

Un Extended est plus précis qu'un Real, mais consomme plus de place mémoire.

Booléen[modifier | modifier le wikitexte]

Un Boolean est une valeur logique. Il peut être vrai (True) ou faux (False). Écrivez :

 var
   a: Boolean;
 begin
   a := True;
   // or
   a := False;

Mais il est difficile de comprendre l'intérêt du booléen tant que vous n'aurez pas vu les structures conditionnelles au chapitre Structures conditionnelles et répétitives.

Enregistrement[modifier | modifier le wikitexte]

Un enregistrement (appelé structure dans certains langages) représente un ensemble de données hétérogènes. Chaque élément est appelé un champ ; la déclaration d'un type enregistrement spécifie le nom et le type de chaque champ. Une déclaration de type enregistrement a la syntaxe suivante :

type nomTypeEnregistrement = record
	listeChamp1: type1;
	  ...
	listeChampn: typen;
	end

Par exemple, la déclaration suivante crée un type enregistrement nommé TDateRec.

type
  TDateRec = record
    Annee: Integer;
    Mois: (Jan, Fev, Mar, Avr, Mai, Jun,
            Jul, Aou, Sep, Oct, Nov, Dec);
    Jour: 1..31;
  end;

Chaque TDateRec contient trois champs : une valeur entière appelée Annee, une valeur d'un type énuméré appelé Mois et une autre valeur entière comprise entre 1 et 31 appelée Jour. Les identificateurs Annee, Mois et Jour sont des noms de champs de TDateRec qui se comportent comme des variables. Néanmoins, la déclaration de type TDateRec n'alloue pas de mémoire pour les champs Annee, Mois et Jour ; la mémoire est allouée quand vous instanciez l'enregistrement, de la manière suivante :

var Record1, Record2: TDateRec;

Cette déclaration de variable crée deux instances de TDateRec, appelées Record1 et Record2.

Vous pouvez accéder aux champs de l'enregistrement en qualifiant le nom de champ avec le nom de l'enregistrement :

Record1.Annee := 1922;
Record1.Mois := Nov;
Record1.Jour := 26;

Ou en utilisant une instruction with :

with Record1 do
begin
  Annee := 1922;
  Mois := Nov;
  Jour := 26;
end;


Delphi
bouton image vers le chapitre précédent Variables et constantes