Целочисленные типы (справочник по C#)
Целочисленные типы представляют целые числа. Все целочисленные типы являются типами значений. Они также простые типы и могут быть инициализированы с помощью литерала. Все целочисленные типы поддерживают арифметические операторы, побитовые логические операторы, операторы сравнения и равенства.
Характеристики целочисленных типов
C# поддерживает следующие предварительно определенные целочисленные типы:
| Ключевое слово или тип C# | Диапазон | Size | Тип .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, и nint nuint типы являются псевдонимами для базовых типов.
По умолчанию все целочисленные типы имеют значение 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 .
Примечание. Строчную букву l можно использовать в качестве суффикса. Однако при этом выдается предупреждение компилятора, так как букву l можно перепутать с цифрой 1 . Для ясности используйте L .
Если значение, представленное целочисленным литералом, превышает 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 = "); Console.WriteLine($"size of 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 Console.WriteLine($"nint.MinValue = "); Console.WriteLine($"nint.MaxValue = "); Console.WriteLine($"nuint.MinValue = "); Console.WriteLine($"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 : Int32.MinValue–Int32.MaxValue.
- для nuint : UInt32.MinValue–UInt32.MaxValue.
nint a = 42 nint a = (nint)42; Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
- Целочисленные типы
- Целочисленные литералы
- Целочисленные типы собственного размера
- C# 11 — числовой IntPtr и UIntPtr
См. также
- справочник по C#
- Типы значений
- Типы с плавающей запятой
- Строки стандартных числовых форматов
- Числовые значения в .NET
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Чем отличается int от uint
Все данные, которые хранятся в памяти, по сути представляют просто набор битов. И именно тип данных определяет, как будут интерпретироваться эти данные и какие операции с ними можно произодить. Язык Go является статически типизированным языком, то есть все используемые в программе данные имеют определенный тип.
Go имеет ряд встроенных типов данных, а также позволяет определять свои типы. Рассмотрим базовые встроенные типы данных, которые мы можем использовать.
Целочисленные типы
Ряд типов представляют целые числа:
- int8 : представляет целое число от -128 до 127 и занимает в памяти 1 байт (8 бит)
- int16 : представляет целое число от -32768 до 32767 и занимает в памяти 2 байта (16 бит)
- int32 : представляет целое число от -2147483648 до 2147483647 и занимает 4 байта (32 бита)
- int64 : представляет целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт (64 бита)
- uint8 : представляет целое число от 0 до 255 и занимает 1 байт
- uint16 : представляет целое число от 0 до 65535 и занимает 2 байта
- uint32 : представляет целое число от 0 до 4294967295 и занимает 4 байта
- uint64 : представляет целое число от 0 до 18 446 744 073 709 551 615 и занимает 8 байт
- byte : синоним типа uint8 , представляет целое число от 0 до 255 и занимает 1 байт
- rune : синоним типа int32 , представляет целое число от -2147483648 до 2147483647 и занимает 4 байта
- int : представляет целое число со знаком, которое в зависимости о платформы может занимать либо 4 байта, либо 8 байт. То есть соответствовать либо int32, либо int64.
- uint : представляет целое беззнаковое число только без знака, которое, аналогично типу int, в зависимости о платформы может занимать либо 4 байта, либо 8 байт. То есть соответствовать либо uint32, либо uint64.
Здесь несложно запомнить, что есть типы со знаком (то есть которые могут быть отрицательными) и есть безнаковые положительные типы, которые начинаются на префикс u (uint32). Ну и также есть byte — синоним для uint8 и rune — синоним для int32.
Стоит отметить типы int и uint. Они имеют наиболее эффективный размер для определенной платформы (32 или 64 бита). Это наиболее используемый тип для представления целых чисел в программе. Причем различные компиляторы могут предоставлять различный размер для этих типов даже для одной и той же платформы.
Примеры определения переменных, которые представляют целочисленные типы:
var a int8 = -1 var b uint8 = 2 var c byte = 3 // byte - синоним типа uint8 var d int16 = -4 var f uint16 = 5 var g int32 = -6 var h rune = -7 // rune - синоним типа int32 var j uint32 = 8 var k int64 = -9 var l uint64 = 10 var m int = 102 var n uint = 105
Числа с плавающей точкой
Для представления дробных чисел есть два типа:
- float32 : представляет число с плавающей точкой от 1.4*10 -45 до 3.4*10 38 (для положительных). Занимает в памяти 4 байта (32 бита)
- float64 : представляет число с плавающей точкой от 4.9*10 -324 до 1.8*10 308 (для положительных) и занимает 8 байт.
Тип float32 обеспечивает шесть десятичных цифр точности, в то время как точность, обеспечиваемая типом float64, составляет около 15 цифр
Примеры использования типов float32 и float64:
var f float32 = 18 var g float32 = 4.5 var d float64 = 0.23 var pi float64 = 3.14 var e float64 = 2.7
В качестве разделителя между целой и дробной частью применяется точка.
Комплексные числа
Существуют отдельные типы для представления комплексных чисел:
- complex64 : комплексное число, где вещественная и мнимая части представляют числа float32
- complex128 : комплексное число, где вещественная и мнимая части представляют числа float64
var f complex64 = 1+2i var g complex128 = 4+3i
Тип bool
Логический тип или тип bool может иметь одно из двух значений: true (истина) или false (ложь).
var isAlive bool = true var isEnabled bool = false
Строки
Строки представлены типом string . В Go строке соответствует строковый литерал — последовательность символов, заключенная в двойные кавычки:
var name string = "Том Сойер"
Кроме обычных символов строка может содержать специальные последовательности (управляющие последовательности), которые начинаются с обратного слеша \. Наиболее распространенные последовательности:
- \n : переход на новую строку
- \r : возврат каретки
- \t : табуляция
- \» : двойная кавычка внутри строк
- \\ : обратный слеш
Значение по умолчанию
Если переменной не присвоено значение, то она имеет значение по умолчанию, которое определено для ее типа. Для числовых типов это число 0, для логического типа — false, для строк — «»(пустая строка).
Неявная типизация
При определении переменной мы можем опускать тип в том случае, если мы явно инициализируем переменную каким-нибудь значением:
var name = "Tom"
В этом случае компилятор на основании значения неявно выводит тип переменной. Если присваивается строка, то то соответственно переменная будет представлять тип string, если присваивается целое число, то переменная представляет тип int и т.д.
То же самое по сути происходит при кратком определении переменной, когда также явным образом не указывается тип данных:
name := "Tom"
При этом стоит учитывать, что если мы не указываем у переменной тип, то ей обязательно надо присвоить некоторое начальное значение. Объявление переменной одновременно без указания типа данных и начального значения будет ошибкой:
var name // ! Ошибка
Надо либо указать тип данных (в этом случае переменная будет иметь значение по умолчанию):
var name string
Либо указать начальное значение, на основании которого выводится тип данных:
var name = "Tom"
Либо и то, и другое одновременно:
var name string = "Tom"
Неявная типизация нескольких переменных:
var ( name = "Tom" age = 27 )
var name, age = "Tom", 27
Arduino.ru
Тип данных unsigned int — беззнаковое целое число, также как и тип int (знаковое) занимает в памяти 2 байта. Но в отличие от int, тип unsigned int может хранить только положительные целые числа в диапазоне от 0 до 65535 (2^16)-1).
Отличие кроется в том как unsigned int использует старший бит, иногда называемый знаковый бит. Если старший бит равен 1, то для типа int компилятор Arduino считает, что это число отрицательное, а остальные 15 bit несут информацию о модуле целого числа в дополнительного кода представления числа, в то время как unsigned int использует все 16 бит для хранения модуля числа.
Пример
unsigned int ledPin = 13;
Синтаксис
unsigned int var = val;
- var — имя переменной
- val — присваиваемое значение
Замечание по использованию типа unsigned int
Когда переменная типа int в следствие арифметической операции достигает своего максимального значения, она «перескакивает» на самое минимальное значение и наоборот:
unsigned int x x = 0; x = x - 1; // x теперь равна 65535 x = x + 1; // x теперь 0
UInt8, UInt16, UInt32, UInt64, UInt256, Int8, Int16, Int32, Int64, Int128, Int256
Целые числа фиксированной длины, без знака или со знаком.
При создании таблиц для целых чисел можно указывать числовые параметры (например TINYINT(8) , SMALLINT(16) , INT(32) , BIGINT(64) ), но ClickHouse их проигнорирует.
Диапазоны Int
- Int8 — [ -128 : 127 ]
- Int16 — [ -32768 : 32767 ]
- Int32 — [ -2147483648 : 2147483647 ]
- Int64 — [ -9223372036854775808 : 9223372036854775807 ]
- Int128 — [ -170141183460469231731687303715884105728 : 170141183460469231731687303715884105727 ]
- Int256 — [ -57896044618658097711785492504343953926634992332820282019728792003956564819968 : 57896044618658097711785492504343953926634992332820282019728792003956564819967 ]
- Int8 — TINYINT , BOOL , BOOLEAN , INT1 .
- Int16 — SMALLINT , INT2 .
- Int32 — INT , INT4 , INTEGER .
- Int64 — BIGINT .
Диапазоны Uint
- UInt8 — [ 0 : 255 ]
- UInt16 — [ 0 : 65535 ]
- UInt32 — [ 0 : 4294967295 ]
- UInt64 — [ 0 : 18446744073709551615 ]
- UInt128 — [ 0 : 340282366920938463463374607431768211455 ]
- UInt256 — [ 0 : 115792089237316195423570985008687907853269984665640564039457584007913129639935 ]