Поделиться через

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

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

Справочные документы на языке C#, выпущенные последней версией языка C#. Она также содержит начальную документацию по функциям в общедоступных предварительных версиях для предстоящего языкового выпуска.

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

Подсказка

Чтобы узнать, когда функция впервые появилась в C#, ознакомьтесь со статьей по журналу версий языка C#.

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

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

Тип/ключевое слово C# Диапазон Размер Тип .NET
sbyte -128 до 127 8-разрядное целое число со знаком System.SByte
byte От 0 до 255 8-битное целое число без знака System.Byte
short -32 768 до 32 767 16-разрядное целое число со знаком System.Int16
ushort От 0 до 65 535 16-разрядное целое число без знака System.UInt16
int -2 147 483 648 до 2 147 483 647 32-разрядное целое число со знаком System.Int32
uint От 0 до 4 294 967 295 32-разрядное целое число без знака System.UInt32
long -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 64-разрядное целое число со знаком System.Int64
ulong От 0 до 18 446 744 073 709 551 615 Целое число без знака 64-битное System.UInt64
nint Зависит от платформы (вычисляемой во время выполнения) Подписанное 32-разрядное или 64-разрядное целое число System.IntPtr
nuint Зависит от платформы (вычисляемой во время выполнения) Целое число без знака 32-битное или 64-битное System.UIntPtr

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

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

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

Типы целых чисел собственного размера представляются внутренне как типы System.IntPtr .NET и System.UIntPtr. 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 представляет число типа 4,294,967,295uint, хотя оно имеет то же битовое представление, что и число типа -1int. Если требуется значение определенного типа, приведите литерал к такому типу. Используйте оператор, unchecked если литеральное значение не может быть представлено в целевом типе. Например, unchecked((int)0xFF_FF_FF_FF) выдает -1.

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

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

    Замечание

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

  • Если литерал включает один из ULсуффиксов , LUuLUlLulUulили lu суффиксов, компилятор назначает тип как .ulong

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

Если компилятор определяет тип целочисленного литерала как int и значение, представленное литералом, находится в диапазоне целевого типа, значение может быть неявно преобразовано в sbyte, byte, short, ushort, uint, ulongnintили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-разрядным диапазоном:

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

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

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

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

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

См. также

  • Last updated on