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

Целочисленные типы (справочник по 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-битных процессах. Их можно использовать для сценариев взаимодействия, с низкоуровневыми библиотеками и для оптимизации производительности в сценариях, где часто выполняются математические операции с целыми числами.

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

По умолчанию все целочисленные типы имеют значение 0.

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

Используйте структуру 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 представляет число 4294967295 типа uint, хотя он имеет то же битовое представление, что и число -1 типа int. Если вам требуется значение определенного типа, приведите литерал к этому типу. Используйте оператор 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(). Но код должен компилироваться в контексте unsafe. Например:

    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 в качестве статических свойств с ключевыми словами nint и nuint, как показано в следующем примере:

    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

  • Значения констант можно использовать в таких диапазонах:

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

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

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

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

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

См. также