RAD Studio - Contributions [fr]

Accueil

2022-02-07T14:03:03Z

Adriana.mercado : Added 10.3

{{DISPLAYTITLE:Aide en ligne de {{Product}} 10.3 {{MarketingVersion}}}}
__NOTOC__

<div class="floatleft" style="width: 49%">
==[[Présentation de RAD Studio|Présentation]]==
* [[Présentation de RAD Studio|Présentation des fonctionnalités]]
* [[Nouveautés|Nouveautés]]
* [[Notes de release|Notes de release]]
* [[10.3 Rio - Release 1]]
* [[10.3 Rio - Release 2]]
* [[10.3 Rio - Release 3]]

==[[Installation|Installation]]==
* [[Notes d'installation|Notes d'installation]]
* [[Plat_fr:Accueil#{{Product}} {{MarketingVersion}}|Correctifs et solutions de contournement]]

==[[Introduction à RAD Studio|Introduction]]==
* [[Tutoriels|Tutoriels]] | [[Tutoriel : Utilisation de l'EDI|Création de votre première application]]
* [[Ressources utiles pour les nouveaux utilisateurs#Exemples de code et exemples d'application|Exemples de code et exemples d'application]]
* [[Ressources utiles pour les nouveaux utilisateurs#Principes de base|Lectures]]
* [[Ressources utiles pour les nouveaux utilisateurs#Démos vidéo|Vidéos]]
* [[Ressources utiles pour les nouveaux utilisateurs#Séminaires CodeRage|Séminaires]]
==Développement de projets==
* [[Types d'applications principaux|Types d'applications principaux]]
* [[Etapes du développement d'un projet|Etapes du développement d'un projet]]
==Référence==
* [[Plates-formes cible prises en charge|Plates-formes cible]]
* [[Frameworks et bibliothèques|Frameworks et bibliothèques]]
* [[Langages de programmation|Langages de programmation]]
* [[Référence EDI et utilitaires|Référence EDI et utilitaires]]
* [[Index|Index]]
</div>

<div class="floatright" style="width: 49%">

{{f|winguide|

==[[Guide du développeur Windows - Index|Développement Windows]]==
* [[VCL|Application Fiches VCL Windows]]
* [[Développement des applications Metropolis UI|Applications Metropolis UI pour la VCL et {{FM}} (Style Windows 8)]]
* [[Guide du concepteur de composants - Index|Guide du concepteur de composants]]

}}

==[[Applications multi-périphériques - Index|Développement multi-périphérique]]==
* [[Développement des applications multi-périphériques|Développement des applications multi-périphériques]]
* [[Etapes de la création d'applications multi-périphériques|Etapes de la création d'applications multi-périphériques]]
* [[Développement d'applications de bases de données|Développement d'applications de bases de données]]
* [[Développement d'applications RAD Server, Cloud et REST|Développement d'applications EMS, Cloud et REST]] {{f|datasnap|
* [[Développement d'applications DataSnap|Développement d'applications DataSnap]] }}
==Développement mobile==
* [[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]
* [[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]
* [[Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)|Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)]]

{{f|radstudio|

==[[Ecriture d'applications Internet - Index|Développement Web]]==
* [[Utilisation de WebBroker - Index|Utilisation de WebBroker]]
==[[Modélisation UML|Modélisation UML]]==
* [[Concepts de modélisation|Concepts de modélisation]]
* [[Procédures de modélisation|Procédures de modélisation]]
* [[Référence de la modélisation - Index|Référence de la modélisation]]

}}

</div>

[[Category:Delphi]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Main Page]]
[[de:Hauptseite]]
[[ja:メインページ]]

Types simples (Delphi)

2020-04-02T21:19:45Z

Adriana.mercado : /* Types réels */ Erased (-(263+1)/10000.. 263/10000)

__TOC__
{{Parent|Types de données, variables et constantes - Index}}
<ideTag id="ordinal"></ideTag>
<ideTag id="real"></ideTag>
<ideTag id="Ingeger"></ideTag>
<ideTag id="Character"></ideTag>
<ideTag id="Boolean"></ideTag>
<ideTag id="Enumerated"></ideTag>
<ideTag id="Real"></ideTag>
<ideTag id="Ordinal"></ideTag>
<ideTag id="Subrange"></ideTag>
<ideTag id="Ord"></ideTag>
<ideTag id="Pred"></ideTag>
<ideTag id="Succ"></ideTag>
<ideTag id="High"></ideTag>
<ideTag id="Low"></ideTag>
<ideTag id="Cardinal"></ideTag>
<ideTag id="cardinal"></ideTag>
<ideTag id="Int32"></ideTag>
<ideTag id="UInt32"></ideTag>
<ideTag id="Shortint"></ideTag>
<ideTag id="Smallint"></ideTag>
<ideTag id="SByte"></ideTag>
<ideTag id="Int16"></ideTag>
<ideTag id="Longint"></ideTag>
<ideTag id="Byte"></ideTag>
<ideTag id="Word"></ideTag>
<ideTag id="Longword"></ideTag>
<ideTag id="UInt16"></ideTag>
<ideTag id="UInt64"></ideTag>
<ideTag id="Inc"></ideTag>
<ideTag id="Dec"></ideTag>
<ideTag id="IntToStr"></ideTag>
<ideTag id="IntToHex"></ideTag>
<ideTag id="Round"></ideTag>
<ideTag id="Trunc"></ideTag>
<ideTag id="StrToInt64"></ideTag>
<ideTag id="StrToInt65Def"></ideTag>
<ideTag id="AnsiChar"></ideTag>
<ideTag id="WideChar"></ideTag>
<ideTag id="Char"></ideTag>
<ideTag id="SizeOf"></ideTag>
<ideTag id="Chr"></ideTag>
<ideTag id="False"></ideTag>
<ideTag id="True"></ideTag>
<ideTag id="<"></ideTag>
<ideTag id=">"></ideTag>
<ideTag id="<>"></ideTag>
<ideTag id="="></ideTag>
<ideTag id="ByteBool"></ideTag>
<ideTag id="WordBool"></ideTag>
<ideTag id="LongBool"></ideTag>
<ideTag id="Ord(False)"></ideTag>
<ideTag id="Ord(True)"></ideTag>
<ideTag id="Succ(False)"></ideTag>
<ideTag id="Pred(True)"></ideTag>
<ideTag id="Real48"></ideTag>
<ideTag id="Single"></ideTag>
<ideTag id="Double"></ideTag>
<ideTag id="Extended"></ideTag>
<ideTag id="Comp"></ideTag>
<ideTag id="Currency"></ideTag>
<ideTag id="($REALCOMPATIBILITY ON)"></ideTag>
Les types simples, qui comportent les types ordinaux et les types réels, définissent des ensembles ordonnés de valeurs.

==Types ordinaux==

Les types ordinaux incluent les types entier, caractère, booléen, énuméré et intervalle. Un type ordinal définit un ensemble ordonné de valeurs dans lequel chaque valeur, sauf la première, a un prédécesseur unique et chaque valeur, sauf la dernière, a un successeur unique. En outre, chaque valeur a un rang qui détermine l'ordre du type. Dans la plupart des cas, si une valeur a le rang ''n'', son prédécesseur a le rang ''n-1'' et son successeur a le rang ''n+1''.

Pour les types entiers, le rang d'une valeur est la valeur elle-même. Les types sous-intervalle conservent les rangs de leurs types de base. Pour les autres types ordinaux, la première valeur a par défaut le rang 0, la suivante a le rang 1, et ainsi de suite. La déclaration d'un type énuméré peut explicitement redéfinir cette valeur par défaut.

Plusieurs fonctions prédéfinies opèrent sur les valeurs ordinales et les identificateurs de type. Les plus importantes sont résumées ci-dessous.

{| border="1" frame="hsides" rules="rows"
|-
! ''' Fonction '''
! ''' Paramètre '''
! ''' Valeur de retour '''
! ''' Remarques '''
|-
|
[[lib_fr:System.Ord|Ord]]
|
Expression ordinale
|
Rang de la valeur de l'expression
|
Ne prend pas d'arguments Int64.
|-
|
[[lib_fr:System.Pred|Pred]]
|
Expression ordinale
|
Prédécesseur de la valeur de l'expression
|
|-
|
[[lib_fr:System.Succ|Succ]]
|
Expression ordinale
|
Successeur de la valeur de l'expression
|
|-
|
[[lib_fr:System.High|High]]
|
Identificateur de type ordinal ou variable de type ordinal
|
Plus grande valeur du type
|
Opère également sur les types chaîne courte et les tableaux.
|-
|
[[lib_fr:System.Low|Low]]
|
Identificateur de type ordinal ou variable de type ordinal
|
Plus petite valeur du type
|
Opère également sur les types chaîne courte et les tableaux.
|}

Par exemple, '''High(Byte)''' renvoie 255 car la plus grande valeur du type [[lib_fr:System.Byte|Byte]] est 255, et '''Succ(2)''' renvoie 3 car 3 est le successeur de 2.

Les procédures standard '''Inc''' et '''Dec''' incrémentent et décrémentent la valeur d'une variable ordinale. Par exemple, '''Inc(I)''' est équivalent à <code>I := Succ(I)</code> et, si <code>I</code> est une variable entière, c'est également équivalent à <code>I := I + 1</code>.

===Types entiers===

Un type entier représente un sous-ensemble des nombres intégraux.

Les types entiers peuvent être ''dépendants de la plate-forme'' et ''indépendants de la plate-forme''.

====Types entiers dépendants de la plate-forme====

Les types entiers dépendants de la plate-forme sont transformés pour s'ajuster à la taille en bits de la plate-forme du compilateur en cours. Les types entiers dépendants de la plate-forme sont
[[lib_fr:System.NativeInt|NativeInt]], [[lib_fr:System.NativeUInt|NativeUInt]], [[lib_fr:System.Longint|LongInt]] et [[lib_fr:System.LongWord|LongWord]]. L'utilisation de ces types est souhaitable dans la mesure du possible, puisqu'ils donnent de meilleures performances pour le système d'exploitation et la CPU sous-jacente. Le tableau suivant illustre leurs intervalles et les formats de stockage pour le compilateur {{Delphi}}.

'''Types entiers dépendants de la plate-forme'''

{| border="1" frame="hsides" rules="rows"
|-
! ''' Type '''
! ''' Intervalle '''
! ''' Format '''
! ''' Alias '''
|-
|
[[lib_fr:System.NativeInt|NativeInt]]
|
<code>-2147483648..2147483647</code> 
<code>-2^63..2^63-1</code>
|
Signé sur 32 bits sur les plates-formes 32 bits ou 
Signé sur 64 bits sur les plates-formes 64 bits
|
[[lib_fr:System.Integer|Integer]] 
[[lib_fr:System.Int64|Int64]]
|-
|
[[lib_fr:System.NativeUInt|NativeUInt]]
|
<code>0..4294967295</code> 
<code>0..2^64-1</code>
|
Non signé sur 32 bits sur les plates-formes 32 bits ou 
Non signé sur 64 bits sur les plates-formes 64 bits
|
[[lib_fr:System.Cardinal|Cardinal]] 
[[lib_fr:System.UInt64|UInt64]]
|-
|
[[lib_fr:System.Longint|LongInt]]
|
<code>-2147483648..2147483647</code> 
<code>-263..263-1</code>
|
Plates-formes Windows 32 bits et 64 bits 
Plates-formes iOS 64 bits
|
[[lib_fr:System.Integer|Integer]] 
[[lib_fr:System.Int64|Int64]]
|-
|
[[lib_fr:System.LongWord|LongWord]]
|
<code>0..4294967295</code> 
<code>0..264-1</code>
|
Plates-formes Windows 32 bits et 64 bits 
Plates-formes iOS 64 bits
|
[[lib_fr:System.Cardinal|Cardinal]] 
[[lib_fr:System.UInt64|UInt64]]
|}

: '''Remarque :''' Les plates-formes 32 bits incluent Windows 32 bits, OSX32, iOS 32 bits et Android.

====Types entiers indépendants de la plate-forme====

Les types entiers indépendants de la plate-forme ont toujours la même taille, quelle que soit la plate-forme utilisée. Les types entiers indépendants de la plate-forme incluent [[lib_fr:System.Shortint|ShortInt]], [[lib_fr:System.Smallint|SmallInt]], [[lib_fr:System.Longint|LongInt]], [[lib_fr:System.Integer|Integer]], [[lib_fr:System.Int64|Int64]], [[lib_fr:System.Byte|Byte]], [[lib_fr:System.Word|Word]], [[lib_fr:System.LongWord|LongWord]], [[lib_fr:System.Cardinal|Cardinal]] et [[lib_fr:System.UInt64|UInt64]].

''' Types entiers indépendants de la plate-forme'''

{| border="1" frame="hsides" rules="rows"
|-
! ''' Type '''
! ''' Intervalle '''
! ''' Format '''
! ''' Alias '''
|-
|
[[lib_fr:System.Shortint|ShortInt]]
|
<code>-128..127</code>
|
Signé sur 8 bits
|
[[lib_fr:System.Int8|Int8]]
|-
|
[[lib_fr:System.Smallint|SmallInt]]
|
<code>-32768..32767</code>
|
Signé sur 16 bits
|
[[lib_fr:System.Int16|Int16]]
|-
|
[[lib_fr:System.FixedInt|FixedInt]]
|
<code>-2147483648..2147483647</code>
|
Signé sur 32 bits
|
[[lib_fr:System.Int32|Int32]]
|-
|
[[lib_fr:System.Integer|Integer]]
|
<code>-2147483648..2147483647</code>
|
Signé sur 32 bits
|
[[lib_fr:System.Int32|Int32]]
|-
|
[[lib_fr:System.Int64|Int64]]
|
<code>-2^63..2^63-1</code>
|
Signé sur 64 bits
|
|-
|
[[lib_fr:System.Byte|Byte]]
|
<code>0..255</code>
|
Non signé sur 8 bits
|
[[lib_fr:System.UInt8|UInt8]]
|-
|
[[lib_fr:System.Word|Word]]
|
<code>0..65535</code>
|
Non signé sur 16 bits
|
[[lib_fr:System.UInt16|UInt16]]
|-
|
[[lib_fr:System.FixedUInt|FixedUInt]]
|
<code>0..4294967295</code>
|
Non signé sur 32 bits
|
[[lib_fr:System.UInt32|UInt32]]
|-
|
[[lib_fr:System.Cardinal|Cardinal]]
|
<code>0..4294967295</code>
|
Non signé sur 32 bits
|
[[lib_fr:System.UInt32|UInt32]]
|-
|
[[lib_fr:System.UInt64|UInt64]]
|
<code>0..2^64-1</code>
|
Non signé sur 64 bits
|
|}

En général, les opérations arithmétiques sur les entiers renvoient une valeur de type [[lib_fr:System.Integer|Integer]], qui est équivalente au type [[lib_fr:System.Longint|LongInt]] sur 32 bits. Les opérations ne renvoient une valeur de type [[lib_fr:System.Int64|Int64]] que si elles portent sur un ou plusieurs opérandes [[lib_fr:System.Int64|Int64]]. Par conséquent, le code suivant produit des résultats incorrects :

var
I: Integer;
J: Int64;
...
I := High(Integer);
J := I + 1;

Pour obtenir une valeur de retour [[lib_fr:System.Int64|Int64]] dans cette situation, transtypez <code>I</code> en [[lib_fr:System.Int64|Int64]] :

...
J := Int64(I) + 1;

Pour de plus amples informations, voir [[Opérateurs arithmétiques|Opérateurs arithmétiques]].

<blockquote>'''Remarque :''' Certaines routines standard qui attendent des arguments entiers tronquent les valeurs [[lib_fr:System.Int64|Int64]] à 32 bits. Toutefois, les routines '''High''', '''Low''', '''Succ''', '''Pred''', '''Inc''', '''Dec''', '''IntToStr''' et '''IntToHex''' supportent complètement les arguments [[lib_fr:System.Int64|Int64]]. De même, les fonctions '''Round''', '''Trunc''', '''StrToInt64''' et '''StrToInt64Def''' renvoient des valeurs [[lib_fr:System.Int64|Int64]]. Quelques routines n'acceptent pas les valeurs [[lib_fr:System.Int64|Int64]].</blockquote>

Quand vous incrémentez la dernière valeur ou décrémentez la première valeur d'un type entier, le résultat boucle sur le début ou la fin de l'intervalle. Par exemple, le type [[lib_fr:System.Shortint|ShortInt]] a l'étendue -128..127 ; donc après l'exécution du code suivant :

var
I: Shortint;
...
I := High(Shortint);
I := I + 1;

la valeur de <code>I</code> est -128. Si la vérification des limites de compilation est activée, ce code génère néanmoins une erreur d'exécution.

===Types caractères===

Les types caractères sont [[lib_fr:System.Char|Char]], [[lib_fr:System.AnsiChar|AnsiChar]], [[lib_fr:System.WideChar|WideChar]], [[lib_fr:System.UCS2Char|UCS2Char]] et [[lib_fr:System.UCS4Char|UCS4Char]] :

* [[lib_fr:System.Char|Char]] dans l'implémentation en cours est équivalent à [[lib_fr:System.WideChar|WideChar]], puisque le type de chaîne par défaut est maintenant [[lib_fr:System.UnicodeString|UnicodeString]]. Puisque l'implémentation de [[lib_fr:System.Char|Char]] peut changer dans les futures releases, il est judicieux d'utiliser la fonction standard [[lib_fr:System.SizeOf|SizeOf]] plutôt qu'une constante codée en dur lors de l'écriture de programmes qui doivent gérer des caractères de tailles différentes.
* Les valeurs [[lib_fr:System.AnsiChar|AnsiChar]] sont des caractères sur un octet (8 bits) ordonnés selon le jeu de caractères local éventuellement multi-octets.
* Les caractères [[lib_fr:System.WideChar|WideChar]] utilisent plus d'un octet pour représenter chaque caractère. Dans les implémentations en cours, les valeurs [[lib_fr:System.WideChar|WideChar]] sont des caractères sur un mot (16 bits) ordonnés selon le jeu de caractères Unicode (ils pourraient être plus longs dans de futures implémentations). Les 256 premiers caractères Unicode correspondent aux caractères ANSI.
* [[lib_fr:System.UCS2Char|UCS2Char]] est un alias pour [[lib_fr:System.WideChar|WideChar]].
* [[lib_fr:System.UCS4Char|UCS4Char]] est utilisé pour fonctionner avec des caractères Unicode sur 4 octets.

Une constante chaîne de longueur 1, comme 'A', peut désigner une valeur caractère. La fonction prédéfinie '''Chr''' renvoie la valeur caractère pour tout entier de l'étendue de [[lib_fr:System.WideChar|WideChar]] ; par exemple '''Chr(65)''' renvoie la lettre A.

Les valeurs [[lib_fr:System.AnsiChar|AnsiChar]] et [[lib_fr:System.WideChar|WideChar]], comme les entiers, bouclent quand elles sont décrémentées ou incrémentées au-delà du début ou de la fin de leur étendue (à moins que la vérification des limites ne soit activée). Ainsi, une fois le code suivant exécuté :

var Letter: AnsiChar;
I: Integer;
begin
Letter := High(Letter);
for I := 1 to 66 do Inc(Letter);
end;

<code>Letter</code> a la valeur A (ASCII 65).

<blockquote> '''Remarque :''' Le type [[lib_fr:System.AnsiChar|AnsiChar]] n'est pas pris en charge par les compilateurs mobiles {{Delphi}}, mais il est utilisé par les compilateurs de bureau {{Delphi}}. Pour davantage d'informations, voir [[Migration du code Delphi en mobile depuis le bureau|Migration du code Delphi en mobile depuis le bureau]].</blockquote>

===Types booléens===

Les 4 types booléens prédéfinis sont [[lib_fr:System.Boolean|Boolean]], [[lib_fr:System.ByteBool|ByteBool]], [[lib_fr:System.WordBool|WordBool]] et [[lib_fr:System.LongBool|LongBool]]. [[lib_fr:System.Boolean|Boolean]] est le type de prédilection. Les autres types existent pour fournir la compatibilité avec les bibliothèques des autres langages et systèmes d'exploitation.

Une variable [[lib_fr:System.Boolean|Boolean]] occupe un octet de mémoire, une variable [[lib_fr:System.ByteBool|ByteBool]] occupe également un octet, une variable [[lib_fr:System.WordBool|WordBool]] occupe 2 octets (un mot), et une variable [[lib_fr:System.LongBool|LongBool]] occupe 4 octets (2 mots).

Les valeurs booléennes sont désignées par les constantes prédéfinies '''True''' et '''False'''. Les relations suivantes s'appliquent :

{| border="1" frame="hsides" rules="rows"
|-
! ''' Boolean '''
! ''' ByteBool, WordBool, LongBool '''
|-
| style="text-align: left; vertical-align: top;" |
<code>False < True</code>
| style="text-align: left; vertical-align: top;" |
<code>False <> True</code>
|-
| style="text-align: left; vertical-align: top;" |
<code>Ord(False) = 0</code>
| style="text-align: left; vertical-align: top;" |
<code>Ord(False) = 0</code>
|-
| style="text-align: left; vertical-align: top;" |
<code>Ord(True) = 1</code>
| style="text-align: left; vertical-align: top;" |
<code>Ord(True) <> 0</code>
|-
| style="text-align: left; vertical-align: top;" |
<code>Succ(False) = True</code>
| style="text-align: left; vertical-align: top;" |
<code>Succ(False) = True</code>
|-
| style="text-align: left; vertical-align: top;" |
<code>Pred(True) = False</code>
| style="text-align: left; vertical-align: top;" |
<code>Pred(False) = True</code>
|}

Une valeur de type [[lib_fr:System.ByteBool|ByteBool]], [[lib_fr:System.LongBool|LongBool]] ou [[lib_fr:System.WordBool|WordBool]] est considérée comme '''True''' quand son rang est non nul. Si une telle valeur apparaît dans un contexte où un [[lib_fr:System.Boolean|Boolean]] est attendu, le compilateur convertit automatiquement toute valeur de rang non nul en '''True'''.

Les remarques précédentes portent sur le rang des valeurs booléennes, non pas sur les valeurs mêmes. Dans {{Delphi}}, les expressions booléennes ne peuvent être comparées avec des entiers ou des réels. Par exemple, si X est une variable entière, l'instruction :

if X then ...;

génère une erreur de compilation. Le transtypage de la variable en un type booléen n'est pas fiable, mais les deux alternatives suivantes fonctionnent.

if X <> 0 then ...; { use an expression that returns a Boolean value }
...
var OK: Boolean; { use a Boolean variable }
...
if X <> 0 then
OK := True;
if OK then ...;

===Types énumérés===

Un type énuméré définit un ensemble ordonné de valeurs en énumérant simplement les identificateurs désignant ces valeurs. Les valeurs n'ont pas de signification propre. Pour déclarer un type énuméré, utilisez la syntaxe suivante :

'''type''' ''typeName'' = (''val1'', ...,''valn'')

où <code>typeName</code> et chaque <code>val</code> sont des identificateurs valides. Par exemple, la déclaration :

type Suit = (Club, Diamond, Heart, Spade);

définit une suite énumérée appelée <code>Suit</code> dont les valeurs possibles sont <code>Club</code>, <code>Diamond</code>, <code>Heart</code> et <code>Spade</code>, où '''Ord(Club)''' renvoie 0, '''Ord(Diamond)''' renvoie 1, et ainsi de suite.

Quand vous déclarez un type énuméré, vous déclarez chaque <code>val</code> comme une constante de type <code>typeName</code>. Si les identificateurs <code>val</code> sont utilisés dans un autre but dans la même portée, il y a un conflit de nom. Si, par exemple vous déclarez le type :

type TSound = (Click, Clack, Clock)

Malheureusement, '''Click''' est aussi le nom d'une méthode définie pour TControl et tous les objets de la VCL qui en descendent. Donc, si vous écrivez une application et créez un gestionnaire d'événement tel que :

procedure TForm1.DBGridEnter(Sender: TObject);
var
Thing: TSound;
begin
...
Thing := Click;
end;

vous obtiendrez une erreur de compilation ; le compilateur interprète '''Click''' dans la portée de la procédure comme une référence à la méthode '''Click''' d'un TForm. Vous pouvez contourner ce problème en qualifiant l'identificateur ; si '''TSound''' est déclarée dans '''MyUnit''', vous devez utiliser :

Thing := MyUnit.Click;

Une meilleure solution consiste néanmoins à choisir des noms de constantes qui ne rentrent pas en conflit avec d'autres identificateurs. Exemples :

type
TSound = (tsClick, tsClack, tsClock);
TMyColor = (mcRed, mcBlue, mcGreen, mcYellow, mcOrange);
Answer = (ansYes, ansNo, ansMaybe)

Vous pouvez utiliser directement la construction <code>(val1, ..., valn)</code> dans les déclarations des variables, comme nom de type :

var MyCard: (Club, Diamond, Heart, Spade);

Mais si vous déclarez <code>MyCard</code> de cette manière, vous ne pouvez pas déclarer une autre variable dans la même portée en utilisant ces identificateurs de constantes. Ainsi :

var Card1: (Club, Diamond, Heart, Spade);
var Card2: (Club, Diamond, Heart, Spade);

génère une erreur de compilation. Mais :

var Card1, Card2: (Club, Diamond, Heart, Spade);

se compile sans problème, tout comme :

type
Suit = (Club, Diamond, Heart, Spade);
var
Card1: Suit;
Card2: Suit;

====Types énumérés avec les rangs explicitement assignés====

Par défaut, le rang des valeurs énumérées commence à 0 et suit la séquence dans laquelle leurs identificateurs sont listés dans la déclaration de type. Vous pouvez redéfinir cela en assignant explicitement les rangs de certaines ou de toutes les valeurs de la déclaration. Pour assigner un rang à une valeur, faites suivre son identificateur de ''= constantExpression'', où ''constantExpression'' est une [[Constantes déclarées|expression constante]] dont le résultat est un entier. Par exemple :

type Size = (Small = 5, Medium = 10, Large = Small + Medium);

définit un type appelé <code>Size</code> dont les valeurs possibles sont <code>Small</code>, <code>Medium</code> et <code>Large</code>, où '''Ord(Small)''' renvoie 5, '''Ord(Medium)''' renvoie 10 et '''Ord(Large)''' renvoie 15.

Un type énuméré est en effet un intervalle dont les valeurs inférieure et supérieure correspondent aux rangs inférieur et supérieur des constantes de la déclaration. Dans l'exemple précédent, le type <code>Size</code> a 11 valeurs possibles dont le rang va de 5 à 15. (Ici, le type <code>array[Size] of Char</code> représente un tableau de 11 caractères.) Seules trois de ces valeurs ont un nom, mais les autres sont accessibles par le biais de transtypages et de routines comme '''Pred''', '''Succ''', '''Inc''' et '''Dec'''. Dans l'exemple suivant, des valeurs "anonymes" dans l'étendue de <code>Size</code> sont assignées à la variable <code>X</code>.

var
X: Size;
X := Small; // Ord(X) = 5
X := Size(6); // Ord(X) = 6
Inc(X); // Ord(X) = 7

Toute valeur à laquelle un rang n'a pas été explicitement assigné a pour rang un de plus que celui de la valeur précédente de la liste. Si aucun rang n'est assigné à la première valeur, son rang est 0. Ici, étant donné la déclaration :

type SomeEnum = (e1, e2, e3 = 1);

<code>SomeEnum</code> a seulement deux valeurs possibles : '''Ord(e1)''' renvoie 0, '''Ord(e2)''' renvoie 1, et '''Ord(e3)''' renvoie également 1 ; comme <code>e2</code> et <code>e3</code> ont le même rang, ils représentent la même valeur.

Les constantes énumérées sans valeur spécifique ont des informations RTTI :

type SomeEnum = (e1, e2, e3);

alors que les constantes énumérées avec une valeur spécifique (comme dans l'exemple ci-dessous) n'en ont pas :

type SomeEnum = (e1 = 1, e2 = 2, e3 = 3);

====Enumérations de portée====

Vous pouvez utiliser les énumérations de portée dans le code {{Delphi}} si vous activez la directive [[Enumérations de portée (Delphi)|{$SCOPEDENUMS ON}]] du compilateur.

La directive [[Enumérations de portée (Delphi)|{$SCOPEDENUMS ON ou OFF}]] du compilateur active ou désactive l'utilisation des énumérations de portée dans le code Delphi. '''{$SCOPEDENUMS ON}''' définit que les énumérations sont des énumérations de portée. '''{$SCOPEDENUMS ON}''' affecte des déclarations de types énumération jusqu'à la directive '''{$SCOPEDENUMS OFF}''' la plus proche. Les identificateurs de l'énumération introduite dans les types énumération déclarés après la directive [[Enumérations de portée (Delphi)|{$SCOPEDENUMS ON}]] ne sont pas ajoutés à la portée globale. Pour utiliser un identificateur d'énumération de portée, vous devez le qualifier avec le nom du type énumération introduisant cet identificateur.

Par exemple, définissons l'unité suivante dans le fichier Unit1.pas

<source lang="delphi">
unit Unit1;
interface
// {$SCOPEDENUMS ON} // clear comment from this directive
type
TMyEnum = (First, Second, Third);
implementation

end.
</source>

et le programme suivant en utilisant cette unité

<source lang="delphi">
program Project1;
{$APPTYPE CONSOLE}

uses
SysUtils, Unit1 in 'Unit1.pas';

var
// First: Integer; // clear comment from this variable
Value: TMyEnum;
begin
try
Value := First;
// Value := TMyEnum.First;
// Value := unit1.First;
except
on E:Exception do
Writeln(E.Classname, ': ', E.Message);
end;
end.
</source>

Nous pouvons maintenant étudier les effets de la directive [[Enumérations de portée (Delphi)|{$SCOPEDENUMS}]] du compilateur sur les portées dans lesquelles les identificateurs <code>First</code>, <code>Second</code> et <code>Third</code>, définis dans l'énumération <code>TMyEnum</code>, sont visibles.

Commencez par '''exécuter (F9)''' ce code. Le code s'exécute correctement. Cela signifie que l'identificateur <code>First</code>, utilisé dans la variable

Value := First;

est l'identificateur de porté globale introduit dans le type énumération

TMyEnum = (First, Second, Third);

A présent, effacez le commentaire de la directive

{$SCOPEDENUMS ON}

du compilateur dans l'unité <code>unit1</code>. Cette directive applique l'énumération <code>TMyEnum</code> à générer. Lancez la commande '''Exécuter'''. L'erreur [[E2003 Identificateur non déclaré : '%s' (Delphi)|E2003 Identificateur non déclaré : 'First']] est générée sur la ligne

Value := First;

Elle vous informe que la directive <code>{$SCOPEDENUMS ON}</code> du compilateur empêche l'ajout de l'identificateur <code>First</code>, introduit dans l'énumération <code>TMyEnum</code> de portée, à la portée globale.

Pour utiliser les identificateurs introduits dans les énumérations de portée, préfixez une référence à un élément d'énumération avec son nom de type. Par exemple, effacez le commentaire dans la seconde version

Value := TMyEnum.First;

de la variable <code>Value</code> (et commentez la première version de <code>Value</code>). Lancez la commande '''Exécuter'''. Le programme s'exécute correctement. Cela signifie que l'identificateur <code>First</code> est connu dans la portée <code>TMyEnum</code>.

Maintenant, commentez la directive

// {$SCOPEDENUMS ON}

du compilateur dans <code>unit1</code>. Puis effacez le commentaire de la déclaration de la variable <code>First</code>

First: Integer;

et utilisez à nouveau la variable

Value := First;

A présent, le code dans <code>program Project1</code> ressemble à :

<source lang="delphi">
var
First: Integer;
Value: TMyEnum;
begin
try
Value := First;
</source>

Lancez la commande '''Exécuter'''. La ligne

First: Integer;

provoque l'erreur [[E2010 Types incompatibles - '%s' et '%s' (Delphi)|E2010 Types incompatibles - 'TMyEnum' et 'Integer']]. Cela signifie que le conflit de nommage se produit entre l'identificateur <code>First</code> de portée globale introduit dans l'énumération <code>TMyEnum</code> et la variable <code>First</code>. Vous pouvez contourner ce conflit en qualifiant l'identificateur <code>First</code> avec l'unité <code>unit1</code> dans laquelle il est défini. Pour cela, commentez à nouveau la première version de la variable <code>Value</code> et effacez le commentaire de la troisième :

Value := unit1.First;

Lancez la commande '''Exécuter'''. Le programme s'exécute correctement. Cela signifie qu'à présent l'identificateur <code>First</code> peut être qualifié avec la portée d'unité <code>unit1</code>. Voyons ce qui se passe si nous activons à nouveau la directive

{$SCOPEDENUMS ON}

du compilateur dans <code>unit1</code>. L'erreur [[E2003 Identificateur non déclaré : '%s' (Delphi)|E2003 Identificateur non déclaré : 'First']] est générée sur la ligne

Value := unit1.First;

Cela signifie que '''{$SCOPEDENUMS ON}''' empêche l'ajout de l'identificateur <code>First</code> de l'énumération dans la portée <code>unit1</code>. A présent l'identificateur <code>First</code> est ajouté seulement dans la portée <code>TMyEnum</code> de l'énumération. Pour vérifier cela, utilisons à nouveau la version

Value := TMyEnum.First;

de la variable <code>Value</code>. Lancez la commande '''Exécuter'''. Le code s'exécute correctement.

===Types sous-intervalle===

Un type sous-intervalle représente un sous-ensemble de valeurs d'un autre type ordinal (appelé le type de base). Toute construction de la forme <code>Low..High</code>, où <code>Low</code> et <code>High</code> sont des expressions constantes du même type ordinal, <code>Low</code> étant inférieur à <code>High</code>, identifie un type sous-intervalle qui inclut toutes les valeurs comprises entre <code>Low</code> et <code>High</code>. Si par exemple, vous déclarez le type énuméré :

type
TColors = (Red, Blue, Green, Yellow, Orange, Purple, White, Black);

vous pouvez définir le type sous-intervalle suivant :

type
TMyColors = Green..White;

Ici '''TMyColors''' inclut les valeurs <code>Green</code>, <code>Yellow</code>, <code>Orange</code>, <code>Purple</code> et <code>White</code>.

Vous pouvez utiliser des constantes numériques ou des caractères (constantes chaîne de longueur 1) pour définir des types sous-intervalle :

type
SomeNumbers = -128..127;
Caps = 'A'..'Z';

Quand vous utilisez des constantes numérique ou caractère pour définir un sous-intervalle, le type de base est le plus petit type entier ou caractère contenant l'intervalle spécifié.

La construction <code>LowerBound..UpperBound</code> fonctionne directement comme nom de type, vous pouvez donc l'utiliser directement dans des déclarations de variables. Par exemple :

var SomeNum: 1..500;

déclare une variable entière dont la valeur est dans l'intervalle allant de 1 à 500.

Le rang de chaque valeur d'un sous-intervalle est préservé depuis le type de base. (Dans le premier exemple, si <code>Color</code> est une variable contenant la valeur <code>Green</code>, '''Ord(Color)''' renvoie 2, que <code>Color</code> soit de type '''TColors''' ou '''TMyColors'''.) Les valeurs ne bouclent pas au début ou à la fin du sous-intervalle même si le type de base est de type entier ou caractère ; l'incrémentation ou la décrémention au-delà des limites d'un sous-intervalle convertit simplement la valeur dans le type de base. Ainsi, tandis que :

type Percentile = 0..99;
var I: Percentile;
...
I := 100;

produit une erreur, le code suivant :

...
I := 99;
Inc(I);

assigne la valeur 100 à <code>I</code> (à moins que la vérification des limites de compilation ne soit activée).

L'utilisation d'expressions constantes dans les définitions des sous-intervalles introduit une difficulté syntaxique. Dans toute déclaration de type, quand le premier caractère significatif après '''=''' est une parenthèse gauche, le compilateur suppose qu'un type énuméré est défini. Ainsi, le code :

const X = 50; Y = 10;
type Scale = (X - Y) * 2..(X + Y) * 2;

produit une erreur. Pour contourner ce problème, il faut réécrire la déclaration de type afin d'éviter la parenthèse de début :

type Scale = 2 * (X - Y)..(X + Y) * 2;

==Types réels==

Un type réel définit un ensemble de nombres pouvant être représentés avec la notation à virgule flottante. Le tableau ci-dessous donne les intervalles et les formats de stockage des types réels sur les plates-formes 32 bits et 64 bits.

'''Types réels'''

{| border="1" frame="hsides" rules="rows"
|-
! Type
! Intervalle positif approximatif
! Chiffres significatifs
! Taille en octets
|-
| [[lib_fr:System.Real48|Real48]]
| <code>2.9e-39 .. 1.7e+38</code>
| 11-12
| 6
|-
| [[lib_fr:System.Single|Single]]
| <code>1.5e-45 .. 3.4e+38</code>
| 7-8
| 4
|-
| [[lib_fr:System.Double|Double]]
| <code>5.0e-324 .. 1.7e+308</code>
| 15-16
| 8
|-
| [[lib_fr:System.Real|Real]]
| <code>5.0e-324 .. 1.7e+308</code>
| 15-16
| 8
|-
| [[lib_fr:System.Extended|Extended]]
|
* Plates-formes '''32''' bits : <code>3.4e-4932 .. 1.1e+4932</code>
* Plates-formes '''64''' bits : <code>5.0e-324 .. 1.7e+308</code>
| 10-20 

15-16
| 10 

8
|-
| [[lib_fr:System.Comp|Comp]]
| <code>-9223372036854775808.. 9223372036854775807</code> <code>(-263.. 263-1)</code>
| 10-20
| 8
|-
| [[lib_fr:System.Currency|Currency]]
| <code>-922337203685477.5808.. 922337203685477.5807</code> 
| 10-20
| 8
|}

Les remarques suivantes s'appliquent aux types réels :

* [[lib_fr:System.Real|Real]] est équivalent à [[lib_fr:System.Double|Double]], dans l'implémentation en cours.

* [[lib_fr:System.Real48|Real48]] est conservé pour la compatibilité descendante. Comme son format de stockage n'est pas natif à l'architecture des processeurs Intel, ce type produit des performances plus mauvaises que les autres types à virgule flottante.

: Le type [[lib_fr:System.Real48|Real48]] sur 6 octets s'appelait [[lib_fr:System.Real|Real]] dans les versions précédentes de Object Pascal. Si vous recompilez du code utilisant l'ancien type [[lib_fr:System.Real|Real]] sur 6 octets dans {{Delphi}}, vous pouvez le changer en [[lib_fr:System.Real48|Real48]]. Vous pouvez également utiliser la directive <code>[[Compatibilité Real48 (Delphi)|{$REALCOMPATIBILITY ON}]]</code> du compilateur qui revient à l'interprétation de [[lib_fr:System.Real|Real]] comme un type sur 6 octets.

* [[lib_fr:System.Extended|Extended]] offre une plus grande précision sur les plates-formes '''32''' bits que les autres types réels.

: Sur les plates-formes '''64''' bits, [[lib_fr:System.Extended|Extended]] est l'alias d'un [[lib_fr:System.Double|Double]] ; c'est-à-dire que la taille du type de données [[lib_fr:System.Extended|Extended]] est de 8 octets. Vous avez ainsi moins de précision en utilisant un type [[lib_fr:System.Extended|Extended]] sur les plates-formes '''64''' bits que sur les plates-formes '''32''' bits, où la taille du type [[lib_fr:System.Extended|Extended]] est de 10 octets. Par conséquent, si vos applications utilisent le type de données [[lib_fr:System.Extended|Extended]] et que vous comptez sur la précision pour les opérations à virgule flottante, cette différence de taille peut affecter vos données. Soyez prudent en utilisant [[lib_fr:System.Extended|Extended]] si vous créez des fichiers de données qui doivent être partagés sur plusieurs plates-formes. Pour de plus amples informations, voir [[Considérations Delphi pour les applications multi-périphériques#Le type de données Extended est de 2 octets plus petit sur les systèmes Windows 64 bits|Le type de données Extended est de 2 octets plus petit sur les systèmes Windows 64 bits]].

* Le type [[lib_fr:System.Comp|Comp]] est un type natif de l'architecture des processeurs Intel et représente un entier sur 64 bits. Il est néanmoins classé parmi les réels car il ne se comporte pas comme un type ordinal. (Par exemple, il n'est pas possible d'incrémenter ou de décrémenter une valeur [[lib_fr:System.Comp|Comp]].) [[lib_fr:System.Comp|Comp]] est conservé uniquement pour la compatibilité descendante. Utilisez le type [[lib_fr:System.Int64|Int64]] pour de meilleures performances.
* [[lib_fr:System.Currency|Currency]] est un type de données à virgule fixe qui minimise les erreurs d'arrondi dans les calculs monétaires. Il est stocké dans un entier sur 64 bits, les 4 chiffres les moins significatifs représentant implicitement les positions décimales. Lorsqu'il est combiné à d'autres types réels dans des affectations et des expressions, les valeurs [[lib_fr:System.Currency|Currency]] sont automatiquement divisées ou multipliées par 10000.

==Voir aussi==

*[[Types de données Delphi|Types de données Delphi]]
*[[A propos des types de données (Delphi)|A propos des types de données (Delphi)]]
*[[Types chaîne (Delphi)|Types chaîne (Delphi)]]
*[[Types structurés (Delphi)|Types structurés (Delphi)]]
*[[Pointeurs et types pointeur (Delphi)|Pointeurs et types pointeur (Delphi)]]
*[[Types procéduraux (Delphi)|Types procéduraux (Delphi)]]
*[[Types variants (Delphi)|Types variants (Delphi)]]
*[[Compatibilité et identité de types (Delphi)|Compatibilité et identité de types (Delphi)]]
*[[Déclaration de types|Types de données, variables et constantes - Index (Delphi)]]
*[[Variables (Delphi)|Variables ({{Delphi}})]]
*[[Constantes déclarées|Constantes déclarées]]
*[[Formats de données internes (Delphi)|Formats de données internes (Delphi)]]
* [[Types de données Windows 64 bits comparés aux types de données Windows 32 bits|Types de données Windows 64 bits comparés aux types de données Windows 32 bits]]
* [[Problèmes d'arrondi des nombres à virgule flottante|Problèmes d'arrondi des nombres à virgule flottante]]
* [[Routines de comparaison des nombres à virgule flottante|Routines de comparaison des nombres à virgule flottante]]
* [[Routines d'arrondi des nombres à virgule flottante|Routines d'arrondi des nombres à virgule flottante]]
* [[Routines de contrôle des nombres à virgule flottante|Routines de contrôle des nombres à virgule flottante]]
* [[Routines intrinsèques de Delphi|Routines intrinsèques de Delphi]]

[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

[[en:Simple Types (Delphi)]]
[[de:Einfache Typen (Delphi)]]
[[ja:単純型（Delphi）]]

Boîte de dialogue Options de projet

2019-04-30T12:37:05Z

Adriana.mercado : RS-93374 (erased paragraph about default option)

{{Parent|Menu Projet}}

{{Menu|Projet > Options}} 
Double-cliquez sur une saisie de projet dans le '''[[Gestionnaire de projets|Gestionnaire de projets]]''' | '''Options'''

Ouvre le dialogue '''Options de projet''' qui gère les options du compilateur et des applications relatives à votre projet. Les modifications que vous apportez à votre projet affectent uniquement le projet en cours. Vous pouvez toutefois également enregistrer vos sélections en tant que paramètres par défaut pour les nouveaux projets.

Une valeur d'option apparaît en '''gras''' si la valeur diffère de la valeur de la configuration parent. Pour revenir à la valeur de la configuration parent, cliquez avec le bouton droit sur le texte de l'option et sélectionnez la commande '''Rétablir''' du menu contextuel. Si vous modifiez les valeurs des options, vous pouvez enregistrer votre jeu de modifications dans une nouvelle configuration ou un nouveau jeu d'options nommé. Vous pouvez permuter sur une autre configuration ou charger un jeu d'options dans la configuration active.

Les '''[[Options de la cible|options de la cible]]''' (c'est-à-dire, la plate-forme et la configuration de construction, et les boutons '''[[Appliquer le jeu d'options|Appliquer]]''' et '''Enregistrer''') sont situées en haut des pages d'options associées au compilateur. Voir également [[Eléments communs des pages Options de projet|Eléments communs des pages Options de projet]]:

==Arborescence des catégories d'options==

Dans l'arborescence des catégories d'options du volet de gauche, cliquez sur un élément pour afficher sa page associée.

La liste suivante présente tous les noeuds de l'arborescence des catégories d'options. Certaines catégories d'options sont uniquement disponibles pour certains langages de programmation et types de projets.

* [[C++ (options partagées)|C++ (options partagées)]]
*[[Compilateur C++|Compilateur C++]]
** [[Options avancées du compilateur C++|Options avancées]]
** [[Compatibilité du compilateur C++|Compatibilité]]
** [[Compilateur C++ - Débogage|Débogage]]
** [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]
** [[Compilateur C++ - Optimisations|Optimisations]]
** [[Compilateur C++ - Sortie|Sortie]]
** [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]
** [[Compilateur C++ - Avertissements|Avertissements]]
*[[Lieur C++|Lieur C++]]
** [[Sortie du lieur C++|Sortie]]
** [[Avertissements du lieur C++|Avertissements]]
* [[Bibliothécaire (TLib)|TLib]]
*[[Compilateur Delphi|Compilateur Delphi]]
** [[Compilation|Compilation]]
** [[Conseils et avertissements|Conseils et avertissements]]
** [[Liaison|Liaison]]
** [[Sortie - C/C++|Sortie - C/C++]]
*[[Options du compilateur de ressources|Compilateur de ressources]]
** [[Répertoires et Conditions du compilateur de ressources|Répertoires et Conditions]]
*[[Options Turbo Assembleur|Turbo Assembleur]]
** [[Répertoires et Conditions Turbo Assembleur|Répertoires et Conditions]]
** [[Turbo Assembleur - Avertissements|Avertissements]]
* [[Evénements de construction|Evénements de construction]] {{f|radstudio|
* [[ATL|ATL]] }}
* [[Liste des droits|Liste des droits]]
* [[Permissions d'utilisation|Permissions d'utilisation]]
* [[Fiches (boîte de dialogue)|Fiches]]
* [[Ordre de construction|Ordre de construction]]
*[[Options de l'application|Application]] {{f|vcl|
**[[Apparence de l'application|Apparence]]
*** [[Fichier d'aide de l'application|Boîte de dialogue Fichier d'aide de l'application]] }}
** [[Orientation de l'application|Orientation]]
* [[Description|Description]]
* [[Informations de version|Informations de version]]
*[[Packages (Options)|Packages]]
** [[Packages d'exécution (Options)|Packages d'exécution]]
*[[Débogueur|Débogueur]]
** [[Tables de symboles du débogueur|Tables de symboles]]
** [[Bloc d'environnement du débogueur|Bloc d'environnement]]
* [[Propriétés de projet|Propriétés de projet]]
* [[Page Approvisionnement|Approvisionnement]]
* [[Dépendances GetIt|Dépendances GetIt]]

==Voir aussi==

* [[Boîte de dialogue Options des outils|Boîte de dialogue Options des outils]]
* [[Gestionnaire de projets|Gestionnaire de projets]]

{{DEFAULTSORT:Boite de dialogue Options de projet}}
[[Category:Référence RAD Studio]]
[[Category:Index des rubriques]]
[[Category:AMMigrate]]

[[en:Project Options Dialog Box]]
[[de:Projektoptionen (Dialogfeld)]]
[[ja:［プロジェクトオプション］ダイアログボックス]]