Целочисленные числовые типы (справочник по C#)

Целочисленные числовые типы представляют целые числа. Все целочисленные числовые типы — это типы значений. Они также простые типы и могут быть инициализированы литералами. Все целочисленные числовые типы поддерживают арифметические, побитовые логические, сравнения и равенства операторов.

Характеристики целочисленных типов

C# поддерживает следующие предопределенные целочисленные типы:

Во всех строках таблицы, кроме последних двух, каждое ключевое слово типа C# из левого столбца является псевдонимом соответствующего типа .NET. Ключевое слово и имя типа .NET являются взаимозаменяемыми. Например, следующие объявления объявляют переменные одного типа:

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

Типы nint и nuint в последних двух строках таблицы являются целыми числами родного размера. Для определения nint можно использовать nuint и контекстные ключевые слова. Это 32-разрядные целые числа при выполнении в 32-разрядном процессе или 64-разрядные целые числа при выполнении в 64-разрядном процессе. Их можно использовать для сценариев взаимодействия, низкоуровневых библиотек и оптимизации производительности в сценариях, где многочисленная математика используется.

Типы целых чисел собственного размера представляются внутренне как типы System.IntPtr .NET и System.UIntPtr. Начиная с C# 11, nint и nuint представляют собой псевдонимы для базовых типов.

Значение по умолчанию каждого целочисленного типа равно нулю. 0

Каждый из целочисленных типов имеет MinValue и MaxValue свойства, обеспечивающие минимальное и максимальное значение этого типа. Эти свойства являются константами во время компиляции, за исключением случаев собственных типов (nint и nuint). Свойства MinValue и MaxValue вычисляются во время выполнения для типов нативного размера. Размеры этих типов зависят от параметров процесса.

Используйте структуру System.Numerics.BigInteger для представления целого числа со знаком без верхних или нижних границ.

Целочисленные литералы

Целочисленные литералы могут быть

• десятичное: без префикса
• шестнадцатеричное: с 0x префиксом или 0X префиксом
• binary: с 0b префиксом или 0B префиксом

В следующем коде показан пример каждого из них:

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

В предыдущем примере также показано использование _ в качестве разделителя цифр. Вы можете использовать разделитель цифр со всеми типами числовых литералов.

Тип целочисленного литерала определяется следующим образом:

• Если литерал не имеет суффикса, его тип является первым из следующих типов, в которых его значение может быть представлено: int, uint, long. ulong

  Замечание

  Литералы интерпретируются как положительные значения. Например, литерал 0xFF_FF_FF_FF представляет число типа 4294967295uint, хотя оно имеет то же битовое представление, что и число типа -1int. Если требуется значение определенного типа, приведите литерал к такому типу. unchecked Используйте оператор, если литеральное значение не может быть представлено в целевом типе. Например, unchecked((int)0xFF_FF_FF_FF) выдает -1.

• Если литерал суффиксирован U или uего тип является первым из следующих типов, в которых его значение может быть представлено: uint, ulong.

• Если литерал суффиксирован L или lего тип является первым из следующих типов, в которых его значение может быть представлено: long, ulong.

  Замечание

  Символ l в нижнем регистре можно использовать в качестве суффикса. Однако это создает предупреждение компилятора, так как буква l может быть перепутана с цифрой 1. Используйте L для ясности.

• Если литерал снабжен суффиксом UL, Ul, uL, ul, LU, Lu, lU или lu, его тип — ulong.

Если значение, представленное целым литералом, превышает UInt64.MaxValue, возникает ошибка компилятора CS1021.

Если определён тип целочисленного литерала int, и значение, представленное этим литералом, находится в диапазоне типа назначения, то это значение может быть неявно преобразовано в sbyte, byte, short, ushort, uint, ulong, nint или nuint.

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

Как показано в предыдущем примере, если значение литерала не находится в диапазоне целевого типа, возникает ошибка компилятора CS0031.

Вы также можете использовать приведение для преобразования значения, представленного целым литералом, в тип, отличный от определенного типа литерала:

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

Преобразования

Вы можете преобразовать любой целочисленный числовой тип в любой другой целочисленный числовой тип. Если целевой тип может хранить все значения исходного типа, преобразование неявно. В противном случае необходимо использовать выражение приведения для выполнения явного преобразования. Дополнительные сведения см. в разделе "Встроенные числовые преобразования".

Целые числа собственного размера

Типы целых чисел собственного размера имеют особое поведение, так как хранилище определяется естественным целым числом на целевом компьютере.

• Чтобы получить размер нативного целого числа во время выполнения, можно использовать sizeof(). Однако код должен быть скомпилирован в небезопасном контексте. Рассмотрим пример.

  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
  

  Вы также можете получить эквивалентное значение из статического IntPtr.Size и UIntPtr.Size свойства.

• Чтобы получить минимальные и максимальные значения целых чисел собственного размера во время выполнения, используйте MinValue и MaxValue в качестве статических свойств с nintnuint ключевыми словами, как показано в следующем примере:

  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
  

• Хотя полный диапазон nint и nuint может быть большим, константы времени компиляции ограничены 32-разрядным диапазоном:

  • Для nint: Int32.MinValue до Int32.MaxValue.
  • Для nuint: UInt32.MinValue до UInt32.MaxValue.

• Компилятор предоставляет неявные и явные преобразования в другие числовые типы. Дополнительные сведения см. в разделе "Встроенные числовые преобразования".

• Нет прямого синтаксиса для целых чисел собственного размера. Нет суффикса, чтобы указать, что литерал является целым числом собственного размера, например L для указания long. Вместо этого можно использовать неявные или явные приведения других целочисленных значений. Рассмотрим пример.

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

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Целочисленные типы
• Целые литералы
• Целочисленные типы данных собственного размера
• C# 11 — числовые IntPtr и UIntPtr

См. также

• типы значений
• Типы с плавающей запятой
• Стандартные строки числового формата
• Числовые значения в .NET