Целочисленные типы (справочник по 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 minvalue c что это
Как и во многих языках программирования, в C# есть своя система типов данных, которая используется для создания переменных. Тип данных определяет внутреннее представление данных, множество значений, которые может принимать объект, а также допустимые действия, которые можно применять над объектом.
В языке C# есть следующие базовые типы данных:
-
bool : хранит значение true или false (логические литералы). Представлен системным типом System.Boolean
bool alive = true; bool isDead = false;
byte bit1 = 1; byte bit2 = 102;
sbyte bit1 = -101; sbyte bit2 = 102;
short n1 = 1; short n2 = 102;
ushort n1 = 1; ushort n2 = 102;
int a = 10; int b = 0b101; // бинарная форма b =5 int c = 0xFF; // шестнадцатеричная форма c = 255
uint a = 10; uint b = 0b101; uint c = 0xFF;
long a = -10; long b = 0b101; long c = 0xFF;
ulong a = 10; ulong b = 0b101; ulong c = 0xFF;
char a = 'A'; char b = '\x5A'; char c = '\u0420';
string hello = "Hello"; string word = "world";
object a = 22; object b = 3.14; object c = "hello code";
Например, определим несколько переменных разных типов и выведем их значения на консоль:
string name = "Tom"; int age = 33; bool isEmployed = false; double weight = 78.65; Console.WriteLine($"Имя: "); Console.WriteLine($"Возраст: "); Console.WriteLine($"Вес: "); Console.WriteLine($"Работает: ");
Для вывода данных на консоль здесь применяется интерполяция: перед строкой ставится знак $ и после этого мы можем вводить в строку в фигурных скобках значения переменных. Консольный вывод программы:
Имя: Tom Возраст: 33 Вес: 78,65 Работает: False
Использование суффиксов
При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы (дробные числа) рассматриваются как значения типа double . И чтобы указать, что дробное число представляет тип float или тип decimal , необходимо к литералу добавлять суффикс: F/f — для float и M/m — для decimal.
float a = 3.14F; float b = 30.6f; decimal c = 1005.8M; decimal d = 334.8m;
Подобным образом все целочисленные литералы рассматриваются как значения типа int . Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u , для типа long — суффикс L/l , а для типа ulong — суффикс UL/ul :
uint a = 10U; long b = 20L; ulong c = 30UL;
Использование системных типов
Выше при перечислении всех базовых типов данных для каждого упоминался системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:
int a = 4; System.Int32 b = 4;
Неявная типизация
Ранее мы явным образом указывали тип переменных, например, int x; . И компилятор при запуске уже знал, что x хранит целочисленное значение.
Однако мы можем использовать и модель неявной типизации:
var hello = "Hell to World"; var c = 20;
Для неявной типизации вместо названия типа данных используется ключевое слово var . Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int , то поэтому в итоге переменная c будет иметь тип int . Аналогично переменной hello присваивается строка, поэтому эта переменная будет иметь тип string
Эти переменные подобны обычным, однако они имеют некоторые ограничения.
Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:
// этот код работает int a; a = 20; // этот код не работает var c; c= 20;
Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null :
// этот код не работает var c=null;
Так как значение null, то компилятор не сможет вывести тип данных.
Int minvalue c что это
Я определил несколько целочисленных переменных с ключевым словом int и использовал заключенные в кавычки строки, так что вы уже знакомы с двумя поддерживаемыми С# типами данных. На самом деле в С# поддерживаются восемь целочисленных типов данных:
Целочисленные типы данных C#
| Количество бит | Со знаком | Без знака |
| 8 | sbyte | byte |
| 16 | short | ushort |
| 32 | int | uint |
| 64 | long | ulong |
Кроме того, в С# поддерживаются два типа данных с плавающей точкой, float и double , соответствующие стандарту ANSI/IEEE 754-1985 — IEEE Standard for Binary Floating-Point Arithmetic (стандарт IEEE двоичной арифметики с плавающей точкой). Количество бит, используемое порядком и мантиссой типов float и double , таково:
Количество бит, используемое типами данных С# с плавающей точкой
| Тип С# | Порядок | Мантисса | Всего бит |
| float | 8 | 24 | 32 |
| double | 11 | 53 | 64 |
Кроме того, в С# поддерживается тип decimal , использующий 128 бит для хранения данных. В состав числа этого типа входят 96-битная мантисса и десятичный масштабирующий множитель от 0 до 28. Тип данных decimal обеспечивает точность около 28 десятичных знаков. Он удобен для хранения и выполнения вычислений над числами с фиксированным количеством десятичных знаков, например, денежных сумм или процентных ставок. Я подробней рассмотрю тип decimal , работу с числами и математические вычисления в С# в приложении Б.
Если в тексте программы на С# попадется число 3.14, компилятор будет считать, что оно имеет тип double . Чтобы указать, что его тип float или decimal , используйте для типа float суффикс f а для decimal — суффикс m .
Вот небольшая программа, показывающая минимальное и максимальное значения каждого из одиннадцати числовых типов данных.
//------------------------------------------- // MinAndMax.cs (C) 2001 by Charles Petzold //------------------------------------------- using System; class MinAndMax < public static void Main() < Console.WriteLine("sbyte: to ", sbyte.MinValue, sbyte.MaxValue); Console.WriteLine("byte: to ", byte.MinValue, byte.MaxValue); Console.WriteLine("short: to ", short.MinValue, short.MaxValue); Console.WriteLine("ushort: to ", ushort.MinValue, ushort.MaxValue); Console.WriteLine("int: to ", int.MinValue, int.MaxValue); Console.WriteLine("uint: to ", uint.MinValue, uint.MaxValue); Console.WriteLine("long: to ", long.MinValue, long.MaxValue); Console.WriteLine("ulong: to ", ulong.MinValue, ulong.MaxValue); Console.WriteLine("float: to ", float.MinValue, float.MaxValue); Console.WriteLine("double: to ", double.MinValue, double.MaxValue); Console.WriteLine("decimal: to ", decimal.MinValue, decimal.MaxValue); > >
Как вы заметили, я поставил после каждого типа данных точку и слова MinValue или MaxValue . Эти два идентификатора являются полями структуры. К концу главы все, что делает эта программа, станет для вас понятным, а пока что просто взглянем на результаты ее выполнения:
sbyte: -128 to 127 byte: 0 to 255 short: -32768 to 32767 ushort: 0 to 65535 int: -2147483648 to 2147483647 uint: 0 to 4294967295 long: -9223372036854775808 to 9223372036854775807 ulong: 0 to 18446744073709551615 float: -3.402823E+38 to 3.402823E+38 double: -1.79769313486232E+308 to 1.79769313486232Е+308 decimal: -79228162514264337593543950335 to 79228162514264337593543950335
В С# поддерживается также тип bool , который может принимать только одно из двух значений: true или false , являющихся ключевыми словами С#. Результаты операций сравнения ( == , != , < , >, = ) — значения типа bool . Можно также описать данные типа bool явно. Приведение типа bool к целочисленным типам допускается ( true преобразуется в 1, а false — в 0), но оно должно быть явно указано в коде.
Тип данных char служит для хранения одного символа, a string — для хранения строк из нескольких символов. Тип данных char отличается от целочисленных типов, и его не следует путать с типами sbyte или byte . К тому же переменные типа char занимают 16 бит (но это не значит, что его можно путать с short или ushort ).
Тип char — 16-битный, так как С# использует кодировку Unicode 1 вместо ASCII. Вместо 7-битного представления символов в базовом варианте ASCII и 8 бит на символ в расширенных наборах символов, ставших общепринятыми на компьютерах, в Unicode для кодировки одного символа используется целых 16 бит. Это позволяет отобразить все буквы, условные обозначения и другие символы всех письменностей мира, которые могут использоваться при работе с компьютером. Unicode является расширением кодировки ASCII. Его первые 128 символов совпадают с символами ASCII.
Типы данных не обязательно определять в начале метода. Как и в C++, можно определить типы данных в том месте метода, где они потребовались.
Переменную можно определить и сразу же инициализировать:
string str = "Hello, World!";
Как только переменной типа string присвоено значение, ее отдельные символы нельзя изменить, однако можно присвоить ей новое значение. Строки не заканчиваются нулем, а количество символов в переменной типа string можно определить так:
str.Length
Length является свойством типа данных string ; концепцию свойств я опишу дальше в этой главе. В приложении В содержится подробная информация по работе со строками в С#.
Чтобы описать переменную-массив, поставьте после типа данных пустые квадратные скобки:
float[] arr;
Тип данных переменной arr — массив чисел с плавающей точкой, но на самом деле arr — это указатель. В языке С# массив является ссылочным типом ( reference type ). Это относится и к строке. Другие типы, о которых я рассказывал ранее, являются размерными ( value types ).
Значение переменной arr при первоначальном определении — null . Для выделения памяти массиву нужно воспользоваться оператором new и указать количество элементов в массиве:
arr = new float[3];
Можно также применить сочетание двух приведенных выше операторов:
float[] arr = new float[3];
Кроме того, при описании массива можно инициализировать его элементы:
float[] arr = new float[3] < 3.14f, 2.17f, 100 >;
Количество инициализирующих значений должно совпадать с объявленным размером массива. При инициализации массива можно опустить размер:
float[] arr = new float[] < 3.14f, 2.17f, 100 >;
и даже — оператор new .
float[] arr = < 3.14f, 2.17f, 100 >;
В дальнейшем в программе можно присвоить переменной arr массив типа float другого размера:
arr = new float[5];
При этом выделяется память для хранения пяти значений типа float , каждое из этих значений первоначально равно 0.
Вы можете спросить: «А что случилось с первым блоком памяти, выделенным для трех значений типа float ?» В С# нет оператора delete . Поскольку на исходный блок памяти больше не ссылается ни одна из переменных программы, он становится объектом сборки мусора ( garbage collection ). В какой-то момент Common Language Runtime освободит память, изначально выделенную массиву.
Как и в случае строк, количество элементов массива можно определить, используя выражение:
arr.Length;
Кроме того, С# позволяет создавать многомерные и невыровненные (jagged) массивы, являющиеся массивами массивов.
Если не нужно взаимодействие с кодом, написанным на другом языке, указатели в программах на С# требуются редко. По умолчанию параметры передаются методам по значению. Это означает, что метод может как угодно изменять параметр, а значение параметра в вызывающем методе не изменится. Чтобы изменить такое поведение параметров, можно использовать ключевые слова ref (reference — ссылка) или out , Например, определить метод, изменяющий передаваемую в качестве параметра переменную, можно так:
void AddFive(ref int i)
А метод, присваивающий переменной значение, выглядит так:
void SetToFive(out int i)
В первом примере переменной i необходимо присвоить значение перед вызовом AddFive , тогда метод AddFive сможет изменить ее значение. Во втором — i при вызове метода может не иметь никакого значения.
Важную роль в С# и .NET Framework играют перечисления. Многие константы .NET Framework определены как перечисления. Приведем пример из пространства имен SystemIO :
public enum FileAccess
Перечисления всегда являются целочисленными типами данных, по умолчанию они имеют тип int . Если не указать значение явно (в данном примере для Read оно указано), первому элементу перечисления присваивается нулевое значение. Следующим элементам присваиваются значения в порядке возрастания.
FileAccess можно использовать при работе с несколькими классами файлового ввода-вывода. (Файловый ввод-вывод подробно рассмотрен в приложении А). Необходимо указывать имя перечисления, затем, через точку имя элемента:
file.Open(FileMode.CreateNew, FileAccess.ReadWrite)
FileMode — это еще одно перечисление класса SystemIO . Если эти два перечисления в методе Open поменять местами, компилятор сообщит об ошибке. Перечисления помогают программисту избегать ошибок, связанных с константами.
1 Дополнительную информацию можно получить на Web-странице http://www.unicode.org или в The Unicode Consortium, The Unicode Standard Version 3.0 (Reading, Mass.: Addison-Wesley, 2000).
Int32.Min Value Поле
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Представляет минимально допустимое значение типа Int32. Это поле является константой.
public: int MinValue = -2147483648;public const int MinValue = -2147483648;val mutable MinValue : intPublic Const MinValue As Integer = -2147483648Значение поля
Value = -2147483648
Примеры
В следующем примере свойство используется MinValue для предотвращения OverflowException при преобразовании в Int32 значение .
using namespace System; void main() < array^ numbersToConvert = gcnew array < 162345, 32183, -54000, Int64::MaxValue/2 >; Int32 newNumber; for each (Int64 number in numbersToConvert) < if ((number >= Int32::MinValue) && (number to an Int32.", newNumber); > else < Console::WriteLine("Unable to convert to an Int32.", number); > > > // The example displays the following output to the console: // Successfully converted 162345 to an Int32. // Successfully converted 32183 to an Int32. // Successfully converted -54000 to an Int32. // Unable to convert 4611686018427387903 to an Int32. using System; public class Class1 < public static void Main() < long[] numbersToConvert = < 162345, 32183, -54000, Int64.MaxValue/2 >; int newNumber; foreach (long number in numbersToConvert) < if (number >= Int32.MinValue && number to an Int32."); > else < Console.WriteLine($"Unable to convert to an Int32."); > > > > // The example displays the following output to the console: // Successfully converted 162345 to an Int32. // Successfully converted 32183 to an Int32. // Successfully converted -54000 to an Int32. // Unable to convert 4611686018427387903 to an Int32. open System let numbersToConvert = [ 162345L; 32183L; -54000L; Int64.MaxValue / 2L ] for number in numbersToConvert do if number >= Int32.MinValue && number to an Int32." else printfn $"Unable to convert to an Int32." // The example displays the following output to the console: // Successfully converted 162345 to an Int32. // Successfully converted 32183 to an Int32. // Successfully converted -54000 to an Int32. // Unable to convert 4611686018427387903 to an Int32. Module modMain Public Sub Main() Dim numbersToConvert() As Long = < 162345, 32183, -54000, Int64.MaxValue\2 >Dim newNumber As Integer For Each number As Long In NumbersToConvert If number >= Int32.MinValue And number to an Int32.", _ newNumber) Else Console.WriteLine("Unable to convert to an Int32.", number) End If Next End Sub End Module ' The example displays the following output to the console: ' Successfully converted 162345 to an Int32. ' Successfully converted 32183 to an Int32. ' Successfully converted -54000 to an Int32. ' Unable to convert 4611686018427387903 to an Int32. Комментарии
Значение этой константы равно -2 147 483 648; то есть шестнадцатеричное 0x80000000.