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. Ils sont également 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 :

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. Il s’agit d’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. À partir de C# 11, les types nint et nuint sont 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 type d’un littéral entier est déterminé par son suffixe 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 est suffixe par U ou u, son type est le premier des types suivants dans lesquels sa valeur peut être représentée : uint, ulong.

• Si le littéral est suffixe par L ou l, 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, cela 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 est suffixé par UL, Ul, uL, ul, LU, Lu, lU ou lu, 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, , , byteshortushortuintulongnint ou :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 est déterminé par 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 de nint et nuint peut être plus grande, les constantes de compilation sont limitées à une plage de 32 bits :

  • Pour nint: Int32.MinValue à Int32.MaxValue.
  • Pour nuint: UInt32.MinValue à UInt32.MaxValue.

• 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# :

• Types intégraux
• Littéraux entiers
• Types intégraux de taille native
• C# 11 - IntPtr et UIntPtr numériques

Voir aussi

• Types de valeur
• Types à virgule flottante
• Chaînes de format numériques standard
• Types numériques dans .NET