Caractères de type (Visual Basic)

2025-06-19

En plus de spécifier un type de données dans une instruction de déclaration, vous pouvez forcer le type de données de certains éléments de programmation avec un caractère de type. Le caractère de type doit suivre immédiatement l’élément, sans caractères intermédiaires d’un type quelconque.

Le caractère de type ne fait pas partie du nom de l’élément. Un élément défini avec un caractère de type peut être référencé sans le caractère de type.

Caractères de type identificateur

Visual Basic fournit un ensemble de caractères de type d’identificateur que vous pouvez utiliser dans une déclaration pour spécifier le type de données d’une variable ou d’une constante. Le tableau suivant présente les caractères de type d’identificateur disponibles avec des exemples d’utilisation.

Caractère de type identificateur	Type de données	Exemple :
`%`	`Integer`	`Dim L%`
`&`	`Long`	`Dim M&`
`@`	`Decimal`	`Const W@ = 37.5`
`!`	`Single`	`Dim Q!`
`#`	`Double`	`Dim X#`
`$`	`String`	`Dim V$ = "Secret"`

Aucun caractère de type d'identificateur n'existe pour les types de données Boolean, Byte, Char, Date, Object, SByte, Short, UInteger, ULong, ou UShort, ni pour les types de données composites tels que les tableaux ou les structures.

Dans certains cas, vous pouvez ajouter le $ caractère à une fonction Visual Basic, par exemple Left$ au lieu de Left, pour obtenir une valeur de type Stringretournée.

Dans tous les cas, le caractère de type d’identificateur doit immédiatement suivre le nom de l’identificateur.

Caractères de type de littéral

Un littéral est une représentation textuelle d’une valeur particulière d’un type de données.

Types littéraux par défaut

La forme d’un littéral tel qu’il apparaît dans votre code détermine généralement son type de données. Le tableau suivant présente ces types par défaut.

Forme textuelle d’un littéral	Type de données par défaut	Exemple :
Numérique, aucune partie fractionnaire	`Integer`	`2147483647`
Numérique, aucune partie fractionnaire, trop grande pour `Integer`	`Long`	`2147483648`
Partie numérique, fractionnaire	`Double`	`1.2`
Entre guillemets doubles	`String`	`"A"`
Placé entre les signes numériques	`Date`	`#5/17/1993 9:32 AM#`

Types littéraux imposés

Visual Basic fournit un ensemble de caractères de type littéral, que vous pouvez utiliser pour forcer un littéral à supposer un type de données autre que celui indiqué par son formulaire. Pour ce faire, ajoutez le caractère à la fin du littéral. Le tableau suivant présente les caractères de type littéral disponibles avec des exemples d’utilisation.

Caractère de type de littéral	Type de données	Exemple :
`S`	`Short`	`I = 347S`
`I`	`Integer`	`J = 347I`
`L`	`Long`	`K = 347L`
`D`	`Decimal`	`X = 347D`
`F`	`Single`	`Y = 347F`
`R`	`Double`	`Z = 347R`
`US`	`UShort`	`L = 347US`
`UI`	`UInteger`	`M = 347UI`
`UL`	`ULong`	`N = 347UL`
`C`	`Char`	`Q = "."C`

Aucun caractère de type littéral n'existe pour les types de données Boolean, Byte, Date, Object, SByte, ou String, ni pour tous les types de données composites tels que les tableaux ou les structures.

Les littéraux peuvent également utiliser les caractères de type d’identificateur (%, &, @, !, #, $), comme les variables, les constantes et les expressions. Toutefois, les caractères de type littéral (S, , I, LDF, R, ) Cpeuvent être utilisés uniquement avec des littéraux.

Dans tous les cas, le caractère de type de littéral doit suivre immédiatement la valeur littérale.

Littéraux hexadécimaux, binaires et octaux

Le compilateur interprète normalement un littéral entier dans le système numérique décimal (base 10). Vous pouvez également définir un littéral entier en tant que nombre hexadécimal (base 16) avec le &H préfixe, sous la forme d’un nombre binaire (base 2) avec le &B préfixe, et en tant que nombre octal (base 8) avec le &O préfixe. Les chiffres qui suivent le préfixe doivent être appropriés pour le système numérique. Le tableau suivant illustre cela.

Base numérique	Préfixe	Valeurs de chiffres valides	Exemple :
Hexadécimal (base 16)	`&H`	0-9 et A-F	`&HFFFF`
Binaire (base 2)	`&B`	0-1	`&B01111100`
Octale (base 8)	`&O`	0-7	`&O77`

À compter de Visual Basic 2017, vous pouvez utiliser le caractère de soulignement (_) comme séparateur de groupe pour améliorer la lisibilité d’un littéral intégral. L’exemple suivant utilise le _ caractère pour regrouper un littéral binaire en groupes 8 bits :

Dim number As Integer = &B00100010_11000101_11001111_11001101

Vous pouvez suivre un littéral préfixé avec un caractère de type de littéral. L’exemple suivant montre ceci.

Dim counter As Short = &H8000S
Dim flags As UShort = &H8000US

Dans l’exemple précédent, counter a la valeur décimale de -32768 et flags a la valeur décimale de +32768.

À compter de Visual Basic 15.5, vous pouvez également utiliser le caractère de soulignement (_) comme séparateur de début entre le préfixe et les chiffres hexadécimaux, binaires ou octaux. Par exemple:

Dim number As Integer = &H_C305_F860

Pour utiliser le caractère de soulignement comme séparateur de début, vous devez ajouter l’élément suivant à votre fichier de projet Visual Basic (*.vbproj) :

<PropertyGroup>
  <LangVersion>15.5</LangVersion>
</PropertyGroup>

Pour plus d’informations, consultez Sélectionner la version du langage Visual Basic.

Partager via