Целые числа (Number) в C#

Обычно, числа можно разделить на два типа: целые числа и плавающие числа.

Типы целых чиселЧисла - это целые числа без десятичного разделителя. Оно может быть положительным или отрицательным.

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

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

На следующем рисунке показаны типы чисел в C#.

Типы целых чисел

Целочисленные числа - это положительные или отрицательные целые числа с десятичным разделителем. C# включает四种 типа данных для целых чисел: байт, короткий整数, целое и длинный整数 (byte, short, int, long).

byte

Тип данных byte хранит числа от 0 до 255. Он занимает 8 бит в памяти. Ключевое слово byte является алиасом структуры Byte в .NET.

sbyte и byte одинаковы, но он может хранить числа от -128 до 127.Ключевое слово sbyte является алиасом структуры SByte в .NET.

byte b1 = 255;
byte b2 = -128; // Ошибка компиляции: константное значение «-128» не может быть преобразовано в «байт»
sbyte sb1 = -128;　
sbyte sb2 = 127;　
Console.WriteLine(Byte.MaxValue); // 255
Console.WriteLine(Byte.MinValue); // 0
Console.WriteLine(SByte.MaxValue); // 127
Console.WriteLine(SByte.MinValue); // -128

short

Тип данных short - это целое число с знаками, которое может хранить числа от -32 768 до 32 767. Оно занимает 16 байт памяти. Ключевое слово short является алиасом структуры Int16 в .NET.

Тип данных ushort - это беззнаковое целое число. Оно может хранить только положительные числа от 0 до 65535. Ключевое слово ushort является алиасом структуры UInt16 в .NET.

short s1 = -32768;
short s2 = 32767;
short s3 = 35000; // Ошибка компиляции: константное значение «35000» не может быть преобразовано в «short»
ushort us1 = 65535;
ushort us2 = -32000; // Ошибка компиляции: константное значение «-32000» не может быть преобразовано в «ushort»
Console.WriteLine(Int16.MaxValue); // 32767
Console.WriteLine(Int16.MinValue); // -32768
Console.WriteLine(UInt16.MaxValue); // 65535
Console.WriteLine(UInt16.MinValue); // 0

int

Тип данных int - это 32-битное целое число с знаками. Оно может хранить числа от -2 147 483 648 до 2 147 483 647. Ключевое слово int является алиасом структуры Int32 в .NET.

uint - это 32-битное беззнаковое целое число. Ключевое слово uint является алиасом структуры UInt32 в .NET. Оно может хранить положительные числа от 0 до 4 294 967 295. (Дополнительно) В конце числа используйте суффикс U или u, чтобы分配 его переменной uint.

int i = -2147483648;
int j = 2147483647;
int k = 4294967295; // Ошибка компиляции: не удалось.Implicitly cast type 'uint' to 'int'.
uint ui1 = 4294967295;
uint ui2 = -1; // Ошибка компиляции: значение константы «-1» не может быть преобразовано в «uint»
Console.WriteLine(Int32.MaxValue);//2147483647
Console.WriteLine(Int32.MinValue);//-2147483648
Console.WriteLine(UInt32.MaxValue);//4294967295
Console.WriteLine(UInt32.MinValue);//0

Тип int также используется для шестнадцатеричных и двоичных чисел. Шестнадцатеричные числа начинаются с префикса 0x или 0X. С версии C# 7.2 двоичные числа начинаются с префикса 0b или 0B.

int hex = 0x2F;
int binary = 0b_0010_1111;
Console.WriteLine(hex);
Console.WriteLine(binary);

long

Тип long - это 64-битное целое число. Он может хранить числа от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807. Его можно分配 переменной типа long с помощью суффикса l или L. Ключевое слово long является синонимом структуры Int64 в .NET.

Тип ulong хранит положительные числа от 0 до 18,446,744,073,709,551,615. Если после числа стоит суффикс UL, Ul, uL, ul, LU, Lu, lU или lu, то его тип ulong. Ключевое слово uint является синонимом структуры UInt64 в .NET.

long l1 = -9223372036854775808;
long l2 = 9223372036854775807;
ulong ul1 = 18223372036854775808ul;
ulong ul2 = 18223372036854775808UL;
Console.WriteLine(Int64.MaxValue);//9223372036854775807
Console.WriteLine(Int64.MinValue);//-9223372036854775808
Console.WriteLine(UInt64.MaxValue); // 18446744073709551615
Console.WriteLine(UInt64.MinValue); // 0

Типы с плавающей запятой

Числа с плавающей запятой - это положительные или отрицательные числа с одним или несколькими десятичными знаками. C# включает три типа чисел с плавающей запятой: float, double и decimal (float, double, decimal).

float

Тип данных float может хранить дроби от 3.4ee038 до 3.4e + 038. Он занимает в памяти 4 байта. Ключевое слово float - это别名 структуры Single в .NET.

Использование текстового суффикса f или F делает его типом float.

float f1 = 123456.5F;
float f2 = 1.123456f;
Console.WriteLine(f1); // 123456.5
Console.WriteLine(f2); // 1.123456

double

Тип данных double может хранить десятичные числа от 1.7eˆ308 до 1.7e + 308. Он занимает в памяти 8 байт. Ключевое слово double - это别名 структуры Double в .NET.

Использование текстового суффикса d или D делает его типом double.

double d1 = 12345678912345.5d;
double d2 = 1.123456789123456d;
Console.WriteLine(d1); // 12345678912345.5
Console.WriteLine(d2); // 1.123456789123456

decimal

Тип данных decimal может хранить десятичные числа от ±1.0 x 10-28 до ±7.9228 x 1028. Он занимает в памяти 16 байт. Decimal - это алиас ключевого слова структуры Decimal в .NET.

Тип decimal имеет более высокую точность и меньший диапазон, чем типы float и double, и поэтому подходит для финансовых и货币ных вычислений.

Использование текстового суффикса m или M делает его типом decimal.

decimal d1 = 123456789123456789123456789.5m;
decimal d2 = 1.1234567891345679123456789123m;
Console.WriteLine(d1);
Console.WriteLine(d2);

Научная нотация

double　d　=　0.12e2;
Console.WriteLine(d);　　//　12;
float　f　=　123.45e-2f;
Console.WriteLine(f);　　//　1.2345
decimal　m　=　1.2e6m;
Console.WriteLine(m);//　1200000