Partager via

Types numériques intégraux (référence C#)

Les types numériques intégraux représentent des nombres entiers. Tous les types numériques intégraux sont des types valeur. Les types intégraux sont des types simples et peuvent être initialisés avec des littéraux. Tous les types numériques intégraux prennent en charge les opérateurs arithmétiques, logiques au niveau du bit, comparaison et égalité .

Caractéristiques des types intégraux

C# prend en charge les types intégraux prédéfinis suivants :

Type de données ou mot clé C# Plage Taille Type .NET
sbyte -128 à 127 Entier 8 bits signé System.SByte
byte 0 à 255 Entier non signé sur 8 bits System.Byte
short -32 768 à 32 767 Entier 16 bits signé System.Int16
ushort 0 à 65 535 Entier non signé 16 bits System.UInt16
int -2 147 483 648 à 2 147 483 647 Entier 32 bits signé System.Int32
uint 0 à 4 294 967 295 Entier 32 bits non signé System.UInt32
long -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 Entier 64 bits signé System.Int64
ulong 0 à 18 446 744 073 709 551 615 Entier 64 bits non signé System.UInt64
nint Dépend de la plateforme (calculée au moment de l’exécution) Entier signé de 32 bits ou de 64 bits System.IntPtr
nuint Dépend de la plateforme (calculée au moment de l’exécution) Entier 32 bits ou 64 bits non signé System.UIntPtr

Dans toutes les lignes de table, à l’exception des deux dernières, chaque mot clé de type C# de la colonne la plus à gauche est un alias pour le type .NET correspondant. Le mot clé et le nom de type .NET sont interchangeables. Par exemple, les déclarations suivantes déclarent des variables du même type :

int a = 123;
System.Int32 b = 123;

Les types nint et nuint des deux dernières lignes de la table sont des entiers de taille native. Vous pouvez utiliser les mots clés contextuels nint et nuint pour définir des entiers de taille native. Les entiers de taille native sont des entiers 32 bits lors de l’exécution dans un processus 32 bits, ou des entiers 64 bits lors de l’exécution dans un processus 64 bits. Ils peuvent être utilisés pour les scénarios d’interopérabilité, les bibliothèques de bas niveau et pour optimiser les performances dans les scénarios où les mathématiques entières sont largement utilisées.

Les types entiers de taille native sont représentés en interne en tant que types System.IntPtr .NET et System.UIntPtr. Les nint types et nuint les types sont des alias pour les types sous-jacents.

La valeur par défaut de chaque type intégral est zéro. 0

Chacun des types intégraux a MinValue et MaxValue propriétés qui fournissent la valeur minimale et maximale de ce type. Ces propriétés sont des constantes au moment de la compilation, à l’exception du cas des types de taille native (nint et nuint). Les propriétés MinValue et MaxValue sont calculées en temps réel pour les types de taille native. Les tailles de ces types dépendent des paramètres de processus.

Utilisez la System.Numerics.BigInteger structure pour représenter un entier signé sans limite supérieure ou inférieure.

Littéraux entiers

Les littéraux entiers peuvent être de type

  • décimal : sans préfixe
  • hexadécimal : avec le préfixe 0x ou 0X
  • binaire : avec le 0b ou le 0B préfixe

Le code suivant illustre un exemple de chacun d’eux :

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

L'exemple précédent montre également l'utilisation de _ en tant que ségrégateur de chiffres. Vous pouvez utiliser le séparateur de chiffres avec tous les types de littéraux numériques.

Le suffixe détermine le type d’un littéral entier comme suit :

  • Si le littéral n’a pas de suffixe, son type est le premier des types suivants dans lesquels sa valeur peut être représentée : int, uint, long, ulong.

    Remarque

    Les littéraux sont interprétés comme des valeurs positives. Par exemple, le littéral 0xFF_FF_FF_FF représente le nombre 4294967295 de type uint, bien qu'il ait la même représentation binaire que le nombre -1 de type int. Si vous avez besoin d’une valeur d’un certain type, castez un littéral en ce type. Utilisez l’opérateur unchecked si une valeur littérale ne peut pas être représentée dans le type cible. Par exemple, unchecked((int)0xFF_FF_FF_FF) produit -1.

  • Si le littéral inclut le U ou u le suffixe, son type est le premier des types suivants dans lesquels sa valeur peut être représentée : uint, ulong.

  • Si le littéral inclut le L ou l le suffixe, son type est le premier des types suivants dans lesquels sa valeur peut être représentée : long, ulong.

    Remarque

    Vous pouvez utiliser la lettre l minuscule comme suffixe. Toutefois, l génère un avertissement du compilateur, car la lettre l peut être confondue avec le chiffre 1. Utilisez-la L pour plus de clarté.

  • Si le littéral inclut l’un ULdes suffixes , ulLUUluLLu, lUou lu suffixes, son type est .ulong

Si la valeur représentée par un littéral entier dépasse UInt64.MaxValue, une erreur du compilateur CS1021 se produit.

Si le type déterminé d’un littéral entier est int et que la valeur représentée par le littéral se trouve dans la plage du type de destination, la valeur peut être convertie implicitement en sbyte, nintushortshortuintbyteulongou :nuint

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

Comme l’illustre l’exemple précédent, si la valeur du littéral n’est pas comprise dans la plage du type de destination, une erreur du compilateur CS0031 se produit.

Vous pouvez également utiliser un cast pour convertir la valeur représentée par un littéral entier en type autre que le type déterminé du littéral :

var signedByte = (sbyte)42;
var longVariable = (long)42;

Transformations

Vous pouvez convertir n’importe quel type numérique intégral en n’importe quel autre type numérique intégral. Si le type de destination peut stocker toutes les valeurs du type source, la conversion est implicite. Sinon, vous devez utiliser une expression de conversion pour effectuer une conversion explicite. Pour plus d’informations, consultez conversions numériques intégrées.

Entiers dimensionnés natifs

Les types entiers de taille native ont un comportement spécial, car le stockage correspond à la taille entière naturelle sur l’ordinateur cible.

  • Pour obtenir la taille d’un entier de taille native au moment de l’exécution, vous pouvez utiliser sizeof(). Toutefois, le code doit être compilé dans un contexte non sécurisé. Par exemple:

    Console.WriteLine($"size of nint = {sizeof(nint)}");
Console.WriteLine($"size of nuint = {sizeof(nuint)}");

// output when run in a 64-bit process
//size of nint = 8
//size of nuint = 8

// output when run in a 32-bit process
//size of nint = 4
//size of nuint = 4

    Vous pouvez également obtenir la valeur équivalente à partir des propriétés statiques IntPtr.Size et UIntPtr.Size.

  • Pour obtenir les valeurs minimales et maximales des entiers de taille native en temps d'exécution, utilisez MinValue et MaxValue comme propriétés statiques avec les mots clés nint et nuint, comme dans l’exemple suivant :

    Console.WriteLine($"nint.MinValue = {nint.MinValue}");
Console.WriteLine($"nint.MaxValue = {nint.MaxValue}");
Console.WriteLine($"nuint.MinValue = {nuint.MinValue}");
Console.WriteLine($"nuint.MaxValue = {nuint.MaxValue}");

// output when run in a 64-bit process
//nint.MinValue = -9223372036854775808
//nint.MaxValue = 9223372036854775807
//nuint.MinValue = 0
//nuint.MaxValue = 18446744073709551615

// output when run in a 32-bit process
//nint.MinValue = -2147483648
//nint.MaxValue = 2147483647
//nuint.MinValue = 0
//nuint.MaxValue = 4294967295

  • Même si la plage complète de constantes et nuint peut être plus grande, les constantes au moment de nint la compilation sont limitées à une plage 32 bits :

  • Le compilateur fournit des conversions implicites et explicites en d’autres types numériques. Pour plus d’informations, consultez conversions numériques intégrées.

  • Il n’existe aucune syntaxe directe pour les littéraux entiers de taille native. Il n’existe aucun suffixe pour indiquer qu’un littéral est un entier de taille native, par L exemple pour indiquer un long. Vous pouvez utiliser des casts implicites ou explicites d’autres valeurs entières à la place. Par exemple:

    nint a = 42
nint a = (nint)42;

Spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

Voir aussi

  • Last updated on