Тонкости работы с числами в c#

Диапазоны значений и знак целочисленных типов данных

Как вы уже знаете из предыдущего урока, переменная с n-ным количеством бит может хранить 2n возможных значений. Но что это за значения? Это значения, которые находятся в диапазоне. Диапазон — это значения от и до, которые может хранить определенный тип данных. Диапазон целочисленной переменной определяется двумя факторами: её размером (измеряется в битах) и её знаком (который может быть signed или unsigned).

Целочисленный тип signed (со знаком) означает, что переменная может содержать как положительные, так и отрицательные числа. Чтобы объявить переменную как signed, используйте ключевое слово :

signed char c;
signed short s;
signed int i;
signed long l;
signed long long ll;

По умолчанию, ключевое слово пишется перед типом данных.

1-байтовая целочисленная переменная со знаком (signed) имеет диапазон значений от -128 до 127, т.е. любое значение от -128 до 127 (включительно) может храниться в ней безопасно.

В некоторых случаях мы можем заранее знать, что отрицательные числа в программе использоваться не будут. Это очень часто встречается при использовании переменных для хранения количества или размера чего-либо (например, ваш рост или вес не может быть отрицательным).

Целочисленный тип unsigned (без знака) может содержать только положительные числа. Чтобы объявить переменную как unsigned, используйте ключевое слово :

unsigned char c;
unsigned short s;
unsigned int i;
unsigned long l;
unsigned long long ll;

1-байтовая целочисленная переменная без знака (unsigned) имеет диапазон значений от 0 до 255.

Обратите внимание, объявление переменной как unsigned означает, что она не сможет содержать отрицательные числа (только положительные). Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Для математиков: Переменная signed с n-ным количеством бит имеет диапазон от -(2n-1) до 2n-1-1. Переменная unsigned с n-ным количеством бит имеет диапазон от 0 до (2n)-1.

Для нематематиков: Используем таблицу

Начинающие программисты иногда путаются между signed и unsigned переменными. Но есть простой способ запомнить их различия. Чем отличается отрицательное число от положительного? Правильно! Минусом спереди. Если минуса нет, значит число — положительное. Следовательно, целочисленный тип со знаком (signed) означает, что минус может присутствовать, т.е. числа могут быть как положительными, так и отрицательными. Целочисленный тип без знака (unsigned) означает, что минус спереди отсутствует, т.е. числа могут быть только положительными.

Размер основных типов данных в C++

Возникает вопрос: «Сколько памяти занимают переменные разных типов данных?». Вы можете удивиться, но размер переменной с любым типом данных зависит от компилятора и/или архитектуры компьютера!

Язык C++ гарантирует только их минимальный размер:

Фактический размер переменных может отличаться на разных компьютерах, поэтому для его определения используют оператор sizeof.

Оператор sizeof — это унарный оператор, который вычисляет и возвращает размер определенной переменной или определенного типа данных в байтах. Вы можете скомпилировать и запустить следующую программу, чтобы выяснить, сколько занимают разные типы данных на вашем компьютере:

#include <iostream>

int main()
{
std::cout << «bool:\t\t» << sizeof(bool) << » bytes» << std::endl;
std::cout << «char:\t\t» << sizeof(char) << » bytes» << std::endl;
std::cout << «wchar_t:\t» << sizeof(wchar_t) << » bytes» << std::endl;
std::cout << «char16_t:\t» << sizeof(char16_t) << » bytes» << std::endl;
std::cout << «char32_t:\t» << sizeof(char32_t) << » bytes» << std::endl;
std::cout << «short:\t\t» << sizeof(short) << » bytes» << std::endl;
std::cout << «int:\t\t» << sizeof(int) << » bytes» << std::endl;
std::cout << «long:\t\t» << sizeof(long) << » bytes» << std::endl;
std::cout << «long long:\t» << sizeof(long long) << » bytes» << std::endl;
std::cout << «float:\t\t» << sizeof(float) << » bytes» << std::endl;
std::cout << «double:\t\t» << sizeof(double) << » bytes» << std::endl;
std::cout << «long double:\t» << sizeof(long double) << » bytes» << std::endl;
return 0;
}

Вот результат, полученный на моем компьютере:

Ваши результаты могут отличаться, если у вас другая архитектура, или другой компилятор

Обратите внимание, оператор sizeof не используется с типом void, так как последний не имеет размера

Если вам интересно, что значит в коде, приведенном выше, то это специальный символ, который используется вместо клавиши TAB. Мы его использовали для выравнивания столбцов. Детально об этом мы еще поговорим на соответствующих уроках.

Интересно то, что sizeof — это один из 3-х операторов в языке C++, который является словом, а не символом (еще есть new и delete).

Вы также можете использовать оператор sizeof и с переменными:

#include <iostream>

int main()
{
int x;
std::cout << «x is » << sizeof(x) << » bytes» << std::endl;
}

Результат выполнения программы:

На следующих уроках мы рассмотрим каждый из фундаментальных типов данных языка С++ по отдельности.

Строки

В С++ нет базового типа строка. Однако есть стандартная библиотека string, которая предоставляет класс для работы со строками.

#include <iostream>
#include <string>

void main() {
	std::string first_name = "Vasya";
	std::string last_name  = { "Pupkin" };
	//конкатенация строк
	auto full_name = first_name + " " + last_name;
	std::string *department = new std::string("Department of copying and scanning");

	std::cout << full_name << std::endl;
	//сравнение строк
	std::string a = "A";
	std::string b = "B";
	if (first_name.compare(last_name) > 0) {
		std::cout << a + " > " + b << std::endl;
	} else {
		std::cout << a + " < " + b << std::endl;
	}
	//подстрока
	std::string subs = department->substr(0, 10);
	std::cout << subs << std::endl;
	//замена подстроки
	std::cout << last_name.replace(0, 1, "G") << std::endl;
	//вставка
	std::string new_department = department->insert(department->length(), " and shreddering");
	std::cout << new_department << std::endl;

	delete department;
	system("pause");
}

Со стандартной библиотекой string познакомимся поздее более подробно.

Q&A

Всё ещё не понятно? – пиши вопросы на ящик

Характеристики целочисленных типовCharacteristics of the integral types

C# поддерживает следующие предварительно определенные целочисленные типы:C# supports the following predefined integral types:

Во всех строках таблицы, кроме двух последних, каждое ключевое слово типа C# из крайнего левого столбца является псевдонимом для соответствующего типа .NET.In all of the table rows except the last two, each C# type keyword from the leftmost column is an alias for the corresponding .NET type. Ключевое слово и имя типа .NET являются взаимозаменяемыми.The keyword and .NET type name are interchangeable. Например, следующие объявления объявляют переменные одного типа:For example, the following declarations declare variables of the same type:

Типы и в последних двух строках таблицы являются целыми числами собственного размера.The and types in the last two rows of the table are native-sized integers. В коде такие числа представлены определенными типами .NET, но в каждом случае ключевое слово и тип .NET не взаимозаменяемы.They are represented internally by the indicated .NET types, but in each case the keyword and the .NET type are not interchangeable. Для и компилятор предоставляет преобразования и операции, как для целочисленных типов. Они отличаются от преобразований и операций для типов указателей и .The compiler provides operations and conversions for and as integer types that it doesn’t provide for the pointer types and . Дополнительные сведения см. в статье о типах и .For more information, see and types.

Дополнительные сведения о целочисленных типах собственного размера см. в статье о и .For information about the native-sized integer types, see and .

По умолчанию все целочисленные типы имеют значение .The default value of each integral type is zero, . Все целочисленные типы, кроме целых чисел собственного размера, имеют константы и с минимальным и максимальным значением этого типа.Each of the integral types except the native-sized types has and constants that provide the minimum and maximum value of that type.

Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.Use the System.Numerics.BigInteger structure to represent a signed integer with no upper or lower bounds.

The Number Types in .NET

Let’s start with a review of the more common number types in .NET. Here’s a few of the basic types:

• Int16 (aka short): A signed integer with 16 bits (2 bytes) of space available.
• Int32 (aka int): A signed integer with 32 bits (4 bytes) of space available.
• Int64 (aka long): A signed integer with 64 bits (8 bytes) of space available.
• Single (aka float): A 32-bit floating point number.
• Double (aka double): A 64-bit floating-point number.
• Decimal (aka decimal): A 128-bit floating-point number with a higher precision and a smaller range than Single or Double.

There’s an interesting thing to point out when comparing and : the range of is ±5.0 × 10−324 to ±1.7 × 10308, while the range of is (-7.9 x 1028 to 7.9 x 1028) / (100 to 28). In other words, the range of is several times larger than the range of . The reason for this is that they are used for quite different things.

Целочисленные литералыInteger literals

Целочисленные литералы могут быть:Integer literals can be

• десятичным числом: без префикса;decimal: without any prefix
• шестнадцатеричным числом: с префиксом или ;hexadecimal: with the or prefix
• двоичными: с префиксом или (доступно в C# 7.0 и более поздних версиях).binary: with the or prefix (available in C# 7.0 and later)

В приведенном ниже коде показан пример каждого из них.The following code demonstrates an example of each:

В предыдущем примере также показано использование в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7.0.The preceding example also shows the use of as a digit separator, which is supported starting with C# 7.0. Цифровой разделитель можно использовать со всеми видами числовых литералов.You can use the digit separator with all kinds of numeric literals.

Тип целочисленного литерала определяется его суффиксом следующим образом:The type of an integer literal is determined by its suffix as follows:

• Если литерал не имеет суффикса, его типом будет первый из следующих типов, в котором может быть представлено его значение: , , , .If the literal has no suffix, its type is the first of the following types in which its value can be represented: , , , .

  Примечание

  Литералы интерпретируется как положительные значения.Literals are interpreted as positive values. Например, литерал представляет число типа , хотя он имеет то же битовое представление, что и число типа .For example, the literal represents the number of the type, though it has the same bit representation as the number of the type. Если вам требуется значение определенного типа, приведите литерал к этому типу.If you need a value of a certain type, cast a literal to that type. Используйте оператор , если представить значение литерала в целевом типе невозможно.Use the operator, if a literal value cannot be represented in the target type. Например, выдает .For example, produces .

• Если у литерала есть суффикс или , его типом будет первый из следующих типов, в котором может быть представлено его значение: , .If the literal is suffixed by or , its type is the first of the following types in which its value can be represented: , .

• Если у литерала есть суффикс или , его типом будет первый из следующих типов, в котором может быть представлено его значение: , .If the literal is suffixed by or , its type is the first of the following types in which its value can be represented: , .

  Примечание

  Строчную букву можно использовать в качестве суффикса.You can use the lowercase letter as a suffix. Однако при этом выдается предупреждение компилятора, так как букву можно перепутать с цифрой .However, this generates a compiler warning because the letter can be confused with the digit . Для ясности используйте .Use for clarity.

• Если у литерала есть суффикс , , , , , , или , его тип — .If the literal is suffixed by , , , , , , , or , its type is .

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.If the value represented by an integer literal exceeds UInt64.MaxValue, a compiler error CS1021 occurs.

Если определенный тип целочисленного литерала — , а значение, представленное литералом, находится в диапазоне целевого типа, значение можно неявно преобразовать в , , , , , , или :If the determined type of an integer literal is and the value represented by the literal is within the range of the destination type, the value can be implicitly converted to , , , , , , or :

Как показано в предыдущем примере, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.As the preceding example shows, if the literal’s value is not within the range of the destination type, a compiler error CS0031 occurs.

Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:You can also use a cast to convert the value represented by an integer literal to the type other than the determined type of the literal:

Целочисленные типы

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

Так, если под переменную какого-либо целочисленного типа выделяется 2 байта, что составляет 16 бит, и ей можно присваивать только положительные числа и ноль, то эти числа будут в диапазоне от 0 до 65535, т. к. 216 = 65536, но одна вариация забирается на нуль. Если же тип допускает отрицательные числа, то диапазон допустимых значений уже будет лежать в пределах от -32768 до +32767.

Часто в программах используется тип int. Вот пример, где происходит объявление и определение (присваивание значений) целочисленных переменных, а также вывод их значений на экран:

#include <stdio.h>
int main() {
    int lines, i;
    int count = ;

    lines = 100;
    i = -1;
    printf("%5d %5d %5d\n", i, count+10, lines);
}

Обратите внимание, что в языке C присваивать значение можно при объявлении переменных. Обычно под переменную типа int, которая может принимать как положительные так и отрицательные значения, отводится 4 байта, что равно 32-м битам

Отсюда допустимый диапазон значений будет лежать в пределах от -2 147 483 648 до 2 147 483 647. Если в исходном коде на C мы объявим переменную int max, присвоим ей максимально допустимое значение, а потом будем его увеличивать, то сообщений об ошибке не будет ни на этапе компиляции, ни на этапе выполнения

Обычно под переменную типа int, которая может принимать как положительные так и отрицательные значения, отводится 4 байта, что равно 32-м битам. Отсюда допустимый диапазон значений будет лежать в пределах от -2 147 483 648 до 2 147 483 647. Если в исходном коде на C мы объявим переменную int max, присвоим ей максимально допустимое значение, а потом будем его увеличивать, то сообщений об ошибке не будет ни на этапе компиляции, ни на этапе выполнения.

#include <stdio.h>

int main() {
    int max = 2147483647;

    printf("%d\n", max+1);
    printf("%d\n", max+2);
    printf("%d\n", max+10);
}

Результат будет таким:

-2147483648
-2147483647
-2147483639

Чтобы понять, почему такое происходит, представьте себе числовую ось не в виде прямой, а в виде окружности. Когда мы достигаем конца, двигаясь например по часовой стрелке, то это значит, что мы пришли в начало. Поэтому, продолжая движение по часовой стрелке, следующее число, которое мы увидим за максимально возможным, – это самое минимальное. Данную особенность языка Си следует иметь в виду при выполнении арифметических действий.

То же самое с минимумом int. Если мы начнем из него вычитать, т. е. двигаться против часовой стрелки, то перескочим максимальную границу и будем идти в направлении уменьшения уже от нее:

#include <stdio.h>

int main() {
    int min = -2147483648;

    printf("%d\n", min-1);
    printf("%d\n", min-2);
    printf("%d\n", min-10);
}

Результат:

2147483647
2147483646
2147483638

Помимо типа int в языке программирования C существуют другие (модифицированные) целочисленные типы:

• short — отводится меньше байтов, чем на int;

• long — отводится больше байтов, чем на int (не всегда, зависит от системы);

• unsigned — столько же байт как у int, но без отрицательных чисел; в результате чего знаковый разряд освобождается, и количество положительных значений увеличивается;

• unsigned short;

• unsigned long.

При выводе длинных чисел следует дополнять спецификацию формата буквой l перед буквой формата. Например:

printf("%ld\n", i);
printf("%15ld\n", i);

Примеры переполнения

Рассмотрим переменную unsigned, которая состоит из 4-х бит. Любое из двоичных чисел, перечисленных в таблице выше, поместится внутри этой переменной.

«Но что произойдет, если мы попытаемся присвоить значение, которое занимает больше 4-х бит?». Правильно! Переполнение. Наша переменная будет хранить только 4 наименее значимых (те, что справа) бита, все остальные — потеряются.

Например, если мы попытаемся поместить число 21 в нашу 4-битную переменную:

Число 21 занимает 5 бит (10101). 4 бита справа (0101) поместятся в переменную, а крайний левый бит (1) просто потеряется. Т.е. наша переменная будет содержать 0101, что равно 101 (нуль спереди не считается), а это уже число 5, а не 21.

Примечание: О конвертации чисел из двоичной системы в десятичную и наоборот будет отдельный урок, где мы всё детально рассмотрим и обсудим.

Теперь рассмотрим пример в коде (тип short занимает 16 бит):

#include <iostream>

int main()
{
unsigned short x = 65535; // наибольшее значение, которое может хранить 16-битная unsigned переменная
std::cout << «x was: » << x << std::endl;
x = x + 1; // 65536 — это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдет переполнение, так как переменнная x не может хранить 17 бит
std::cout << «x is now: » << x << std::endl;
return 0;
}

Результат выполнения программы:

Что случилось? Произошло переполнение, так как мы попытались присвоить переменной  значение больше, чем она способна в себе хранить.

Для тех, кто хочет знать больше: Число 65 535 в двоичной системе счисления представлено как 1111 1111 1111 1111. 65 535 — это наибольшее число, которое может хранить 2-байтовая (16 бит) целочисленная переменная без знака, так как это число использует все 16 бит. Когда мы добавляем 1, то получаем число 65 536. Число 65 536 представлено в двоичной системе как 1 0000 0000 0000 0000, и занимает 17 бит! Следовательно, самый главный бит (которым является 1) теряется, а все 16 бит справа — остаются. Комбинация 0000 0000 0000 0000 соответствует десятичному 0, что и является нашим результатом.

Аналогичным образом, мы получим переполнение, использовав число меньше минимального из диапазона допустимых значений:

#include <iostream>

int main()
{
unsigned short x = 0; // наименьшее значение, которое 2-байтовая unsigned переменная может хранить
std::cout << «x was: » << x << std::endl;
x = x — 1; // переполнение!
std::cout << «x is now: » << x << std::endl;
return 0;
}

Результат выполнения программы:

Переполнение приводит к потере информации, а это никогда не приветствуется. Если есть хоть малейшее подозрение или предположение, что значением переменной может быть число, которое находится вне диапазона допустимых значений используемого типа данных — используйте тип данных побольше!

Правило: Никогда не допускайте возникновения переполнения в ваших программах!

Арифметика

Продвижение/преобразование

• Унарный арифметический оператор применяется только к одному операнду. Примеры: , .
• Бинарный оператор применяется к двум операндам. Примеры: , , . .
• Если операнд имеет тип , или (как , так и ), тогда он продвигается до (), если может содержать все значения исходного типа. В противном случае он продвигается до . Процесс продвижения происходит без потерь. Примеры:
  • В реализации присутствуют 16-битный и 24-битный . Если переменные и имеют тип , то операция продвигает оба операнда до .
  • В реализации присутствуют 32-битный и 32-битный . Если переменные и имеют тип , то операция продвигает оба операнда до .
• В случае двоичных операторов оба операнда перед арифметической операцией неявно преобразуются в одинаковый общий тип. Ранги преобразования возрастают в следующем порядке: , , . Рангом общего типа считается старший ранг среди типов двух операндов. Если оба операнда являются , то их общий тип будет иметь ту же характеристику. Если же операнд с беззнаковым типом имеет старший или равный ранг по отношению ко второму операнду, то их общий тип будет беззнаковым. В случае, когда тип операнда со знаком может представлять все значения другого типа операнда, общий тип будет иметь знак. В противном случае общий тип получается беззнаковым. Примеры:
  • ;
  • ;
  • ;
  • если является 32-битным, а long 64-битным: ;
  • если и оба являются 32-битными: .

Неопределенное поведение

Знаковое переполнение:

• При выполнении арифметических операций над целочисленным типом переполнение считается неопределенным поведением (UB). Такое поведение может вызывать верные, несогласованные и/или неверные действия как сразу, так и в дальнейшем.
• При выполнении арифметики над беззнаковым целым (после продвижений и преобразований) любое переполнение гарантированно вызовет оборот значения. Например, .
• Выполнение арифметики над беззнаковыми целыми фиксированного размера может привести к едва уловимым ошибкам. Например:
  • Пусть , и равен 32-битам. Тогда , ,; и будут продвинуты до , и приведет к переполнению , вызвав неопределенное поведение.
  • Пусть , и равен 33-битам. Тогда , , ; и будут продвинуты до , и приведет к переполнению , то есть неопределенному поведению.
  • Чтобы обеспечить безопасную арифметику с беззнаковыми целыми, нужно либо прибавить , либо умножить на в качестве пустой операции. Например: или . Это гарантирует, что операнды будут продвинуты как минимум до ранга и при этом останутся без знаков.

Деление/остаток:

• Деление на нуль и остаток с делителем нуля также относятся к неопределенному поведению.
• Беззнаковое деление/остаток не имеют других особых случаев.
• Деление со знаком может вызывать переполнение, например .
• Остаток со знаком при отрицательных операндах может вызывать сложности, так как некоторые части являются однообразными, в то время как другие определяются реализацией.

Битовые сдвиги:

• Неопределенным поведением считается битовый сдвиг (< < и >>) на размер, который либо отрицателен, либо равен или больше битовой ширины.
• Левый сдвиг беззнакового операнда (после продвижения/преобразования) считается определенным правильно и отклонений в поведении не вызывает.
• Левый сдвиг операнда со знаком, содержащего неотрицательное значение, вследствие которого 1 бит переходит в знаковый бит, является неопределенным поведением.
• Левый сдвиг отрицательного значения относится к неопределенному поведению.
• Правый сдвиг неотрицательного значения (в типе операнда без знака или со знаком) считается определенным правильно и отклонений в поведении не вызывает.
• Правый сдвиг отрицательного значения определяется реализацией.

Битовые поля

Используя структуры, можно упаковать целочисленные компоненты еще более плотно, чем это было сделано с использованием массива.
Набор разрядов целого числа можно разбить на битовые поля, каждое из которых выделяется для определенной переменной. При работе с битовыми полями количество битов, выделяемое для хранения каждого поля отделяется от имени двоеточием

 
тип имя: КоличествоБит

При работе с битовыми полями нужно внимательно следить за тем, чтобы значение переменной не потребовало памяти больше, чем под неё выделено.Пример Разработать программу, осуществляющую упаковку даты в формат

1234567891011121314151617181920212223

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>#define YEAR0 1980struct date{  unsigned short day : 5;  unsigned short month : 4;  unsigned short year : 7;};int main() {  struct date today;  system(«chcp 1251»);  system(«cls»);  today.day = 16;  today.month = 12;  today.year = 2013 — YEAR0; //today.year = 33  printf(«\n Сегодня %u.%u.%u \n», today.day, today.month, today.year + YEAR0);  printf(«\n Размер структуры today : %d байт», sizeof(today));  printf(«\n Значение элемента today = %hu = %hx шестн.», today, today);  getchar();  return 0;}