Partager via

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

  • Article

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, de comparaison et d’égalité.

Caractéristiques des types intégraux

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

C# type/mot clé Plage Taille Type .NET
sbyte -128 à 127 Entier 8 bits signé System.SByte
byte 0 à 255 Entier 8 bits non signé System.Byte
short -32 768 à 32 767 Entier 16 bits signé System.Int16
ushort 0 à 65 535 Entier 16 bits non signé System.UInt16
int -2 147 483 648 à 2 147 483 647 Entier 32 bits signé System.Int32
uint de 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 de 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 du runtime) Entier 32 bits ou 64 bits signé System.IntPtr
nuint Dépend de la plateforme (calculée au moment du runtime) 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 dans les 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 d’entiers 64 bits lors de l’exécution dans un processus 64 bits. Utilisez-les 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 avec des entiers sont très utilisées.

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

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

Chacun des types intégraux possède des propriétés MinValue et MaxValue 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 au moment du runtime pour les types de taille native. Les tailles de ces types dépendent des paramètres de processus.

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

Littéraux d'entier

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 préfixe 0b ou 0B

Le code suivant illustre un exemple de chaque :

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

L’exemple précédent montre également l’utilisation de _ comme séparateur de chiffres. Vous pouvez utiliser le séparateur de chiffres avec tous types de littéraux numériques.

Le type d’un littéral entier est déterminé par son suffixe comme suit :

  • Quand 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.

    Notes

    Les littéraux sont interprétés comme des valeurs positives. Par exemple, le littéral 0xFF_FF_FF_FF représente le numéro 4294967295 du type uint, bien qu’il ait la même représentation de bits que le nombre -1 du 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.

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

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

    Notes

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

  • Si le littéral possède un suffixe 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 de compilation 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, byte, shortushort, uint, ulong, nint 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 dans la plage du type de destination, une erreur de 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;

Conversions

Vous pouvez convertir n’importe quel type numérique intégral en tout 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 cast pour effectuer une conversion explicite. Pour plus d’informations, consultez Conversions numériques intégrées.

Entiers dimensionnés natifs

Les types d’entiers de taille native présentent un comportement spécial, car le stockage est déterminé par la taille d’entier naturelle sur l’ordinateur cible.

  • Pour obtenir la taille d’un entier natif 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 au moment de l’exécution, utilisez MinValue et MaxValue en tant que 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

  • Vous pouvez utiliser des valeurs constantes dans les plages suivantes :

  • Le compilateur fournit des conversions implicites et explicites vers 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 d’entiers de taille native. Il n’existe aucun suffixe pour indiquer qu’un littéral est un entier de taille native, par exemple L 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