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

Les types numériques intégral 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, logiques, 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 de l’exécution) Entier signé 32 bits ou 64 bits System.IntPtr
nuint Dépend de la plateforme (calculée au moment de l’exécution) Entier non signé 32 bits ou 64 bits 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 du 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 nint types et nuint les types des deux dernières lignes de la table sont des entiers de taille native. À partir de C# 9.0, vous pouvez utiliser les mots clés et nuint les nint mots clés 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. Elles peuvent être utilisées pour les scénarios d’interopérabilité, les bibliothèques de bas niveau et optimiser les performances dans les scénarios où les mathématiques entières sont utilisées largement.

Les types entiers de taille native sont représentés en interne en tant que types System.IntPtr .NET et System.UIntPtr. À compter de C# 11, les nint types et nuint les types 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égral a et MaxValue des MinValue propriétés qui fournissent la valeur minimale et maximale de ce type. Ces propriétés sont des constantes de compilation à l’exception du cas des types de taille native (nint et nuint). Les propriétés et MaxValue les MinValue propriétés sont calculées au moment de l’exécution 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

  • décimal : sans préfixe
  • hexadécimal : avec le ou 0X le 0x préfixe
  • binaire : avec le ou 0B 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 d’un _séparateur 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.

    Notes

    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 du uint type, bien qu’il ait la même représentation de bits que le int nombre -1 du type. Si vous avez besoin d’une valeur d’un certain type, castez un littéral sur 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.

    Notes

    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-le L pour plus de clarté.

  • Si le littéral est suffixe par UL, uLLuUlLUlUulou 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, shortuintushort, , ulongou : nintnuint

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 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;

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 de cast 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 et UIntPtr.Size statiquesIntPtr.Size.

  • Pour obtenir les valeurs minimales et maximales des entiers de taille native au moment de l’exécution, utilisez MinValue et MaxValue comme propriétés statiques avec les mots clés et nuint les nint mots clés, 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 entiers de taille native. Il n’y a pas de 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