Перейти к содержимому

Числовые преобразования

  • Явные и неявные преобразования числовых типов
  • static_cast и тип результата
  • Преобразование в целочисленные типы большего и меньшего размера
  • Знаковость и представление целых чисел
  • Побитовые операции (углублённый уровень)

Объясните тип и значение результата каждого преобразования. Проверьте рассуждения, запустив примеры с определённым поведением.

Если main не показана, поместите код в обычный исходный файл с функцией main:

#include <iostream>
#include <cstdint>
int main()
{
// ваш код здесь
}
auto a{ static_cast<uint8_t>(5) };
Что делает static_cast<uint8_t>?

static_cast<uint8_t>(5) это выражение, результатом которого является число 5 типа uint8_t.

  • static_cast говорит, “конвертируй результат выражения из одного типа в другой”.
  • <uint8_t> показывает, в какой тип нужно переконвертировать.
  • (5) в скобках задается выражение, результат которого нужно переконвертировать.

То есть произойдет следующее:

  • Вычисляется выражение из круглых скобок ((5)), получаем число 5 типа int.
  • Выполняется static_cast в тип, указанный внутри <...>, то есть в uint8_t. Поскольку 5 влезает в 1 байт, конвертируется без проблем.
  • static_cast<uint8_t>(5) заменяется на число 5 типа uint8_t.
  • auto воспринимает тип присваиваемого выражения, заменяется на uint8_t.
int value{ 7 };
double half{ static_cast<double>(value) / 2 };
int integerHalf{ value / 2 };
std::cout << value << std::endl;
std::cout << half << std::endl;
std::cout << integerHalf << std::endl;
Ответ

Печатает 7, 3.5 и 3. static_cast<double>(value) создаёт выражение типа double для первого деления. Тип и сохранённое значение переменной value типа int не меняются. Во втором делении по-прежнему используются целые числа, поэтому результат — 3. Перед делением оба операнда приводятся к одному числовому типу. Один операнд уже имеет тип double, поэтому второй автоматически преобразуется в double. Используемые здесь значения типа int помещаются в double, поэтому их значения сохраняются. Компилятор выполняет преобразование, равнозначное static_cast<double>(2), как при преобразовании меньшего целочисленного типа в больший. Если записать оба преобразования явно, первое деление выглядит так:

double half{ static_cast<double>(value) / static_cast<double>(2) };
uint8_t a{ 5 };
int b{ static_cast<int>(a) };
Выполнение по шагам
Ответ

static_cast<int> здесь произойдет даже если его не написать. Так как любое число, сохраненное в a, всегда влезет в b, можно просто присвоить к b переменную a, что совершит конверсию из uint8_t в int автоматически.

4. static_cast отрицательного числа в больший тип

Заголовок раздела «4. static_cast отрицательного числа в больший тип»
int8_t a{ -3 };
int b{ static_cast<int>(a) };
Выполнение по шагам
Ответ

Как и в прошлом примере, конверсия произойдет автоматически даже без static_cast, потому что любое число, сохраненное в a, влезет в b.

Конверсия сохраняет значение, а значит и знак: раз a отрицательное, верхние биты b заполнятся 1. -3 это 1111 1101 в 8 битах и 1111 1111 1111 1111 1111 1111 1111 1101 в 32 битах.

#include <cstdint>
#include <iostream>
int main()
{
uint32_t a{ 256 };
uint8_t b{ static_cast<uint8_t>(a) };
uint32_t c{ b };
std::cout << c << std::endl;
}
Выполнение по шагам
Что делает static_cast<uint8_t>?

В данном примере, он берет только младший байт числа от a, отсекая старшие 3 байта. Это называется truncation.

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

Чтобы подобные ситуации определялись и останавливались компилятором, необходимо передать флаги предупреждений, компилируя, например, вот так:

g++ test.cpp -Wall -Werror -Wconversion

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

uint8_t b { 256 }; // сужающее преобразование

А следующее вероятно даст предупреждение:

uint32_t a { 256 };
uint8_t b { a }; // сужающее преобразование
Правильный ответ:

static_cast<uint8_t> обрезает значение a (truncation), оставляя только последний байт (наименьший байт).

Ответ будет 0, потому что число 256 имеет запись 1 0000 0000 в двоичной системе, а обрезание этого числа до 8 бит оставит лишь 0000 0000, удалив старшую 1.

То же значение со всеми 32 битами, под каждыми 4 битами написана их 16-чная цифра:

0000 0000 0000 0000 0000 0001 0000 0000
0 0 0 0 0 1 0 0

Как читать эту запись: в верхней строке биты, разбитые на группы по 4 (одна группа на 16-чную цифру, между целыми байтами промежуток пошире); в нижней строке под каждыми 4 битами стоит их 16-чная цифра. Читая нижнюю строку, получаем 0x00000100, то есть 256. При обрезании до uint8_t остается только последний байт (0000 0000), поэтому ответ 0.

Что будет, если в a сохранить другое значение?
  • Значение 257: Сохранится 1 0000 0001, что оставит 0000 0001 при отсечении.
  • Значение 258: Сохранится 1 0000 0010, что оставит 0000 0010 при отсечении.
  • Значение 511: Сохранится 1 1111 1111, что оставит 1111 1111 при отсечении.
  • Значение 512: Сохранится 10 0000 0000, что оставит 0000 0000 при отсечении.

6. static_cast отрицательного числа в меньший тип

Заголовок раздела «6. static_cast отрицательного числа в меньший тип»
#include <cstdint>
#include <iostream>
int main()
{
int a{ -3 };
int8_t b{ static_cast<int8_t>(a) };
std::cout << static_cast<int>(b) << std::endl;
int c{ -200 };
int8_t d{ static_cast<int8_t>(c) };
std::cout << static_cast<int>(d) << std::endl;
}
Выполнение по шагам
Ответ

Отрицательные числа обрезаются так же: остаётся только последний байт.

-3 в 32 битах — это 1111 1111 1111 1111 1111 1111 1111 1101. Последний байт, 1111 1101, — это ровно -3 в 8 битах, так что значение помещается и сохраняется: выведется -3. Это обратная операция к расширению знака из примера выше.

-200 в 32 битах — это 1111 1111 1111 1111 1111 1111 0011 1000. В int8_t оно не помещается: этот тип хранит значения от -128 до 127. Последний байт, 0011 1000, начинается с 0, значит, это положительное число 56. Поменялось не только значение, но даже знак: выведется 56.

static_cast<int> при печати нужен, потому что std::cout печатает int8_t как символ.

7. Побитовая операция (продвинутый уровень)

Заголовок раздела «7. Побитовая операция (продвинутый уровень)»
#include <cstdint>
#include <iostream>
int main()
{
uint8_t a{ 0 };
uint8_t b{ static_cast<uint8_t>(~a) };
int32_t c{ b };
std::cout << c;
}
Выполнение по шагам

Что делает ~?

Это побитовый оператор, который переделывает все 0 в 1 в двоичном представлении числа. Например, 1010 0011 -> 0101 1100.

Правильный ответ
  • 0 сохраняется в переменную на 8 бит.
  • Перед применением ~ переменная a преобразуется в int: операторы не работают с типами меньше int. Поэтому ~ переворачивает 32 бита, а не 8: 32 нуля становятся 32 единицами, а это -1.
  • static_cast<uint8_t> оставляет только последний байт: 1111 1111 (255). Преобразование нужно написать явно: фигурные скобки не дадут int самому сузиться до uint8_t.
  • Результат сохраняется в 8-битную b.
  • Результат пересохраняется как есть в 32-битный c (для печати).

Та же запись, под каждыми 4 битами их 16-чная цифра:

a:
0000 0000
0 0
b:
1111 1111
F F
c:
0000 0000 0000 0000 0000 0000 1111 1111
0 0 0 0 0 0 F F

Поскольку b без знака, старший бит считается обычным положительным битом, поэтому старшие 3 байта c заполнятся 0 (zero extension): в c окажется 0x000000FF, и программа напечатает 255. Тип со знаком, наоборот, воспринимает старший бит как имеющий отрицательный коэффициент, поэтому при расширении отрицательного значения верхние биты заполняются 1.

#include <cstdint>
#include <iostream>
int main()
{
uint8_t a{ 127 };
int8_t b{ static_cast<int8_t>(a) };
int32_t c{ b };
std::cout << c;
}
Выполнение по шагам

Что делает static_cast<int8_t>?

В данном примере, он воспринимает представление числа сохраненное в a как есть, но со знаком.

Например, если a равен 0, в ответе будет 0, потому что 0000 0000 что как целое со знаком, что без знака, является значением 0.

Если a равен 128, то есть 1000 0000, станет -128, потому что 1000 0000 как число со знаком это -128.

Что делает присваивание к int32_t для меньшего типа со знаком int8_t?

Если значение отрицательное, ответ тоже будет отрицательным (верхние биты заполнятся 1). Например, -1 записывается как 1111 1111 в 8 битах, станет 1111 1111 1111 1111 1111 1111 1111 1111 в 32 битах, что тоже равно -1.

Если значение положительное, ответ тоже будет положительным (верхние биты заполняются 0). Например, 10 записывается как 0000 1010 в 8 битах, станет 0000 0000 0000 0000 0000 0000 0000 1010 в 32 битах, что тоже равно 10.

Короче говоря, в int32_t будет всегда храниться то же числовое значение.

Правильный ответ:
  • 127 записывается в a как 0111 1111.
  • 0111 1111 конвертируется как есть в b, а 0111 1111 как число со знаком — 127
  • значение 127 сохраняется в c как значение 127 (см. выше объяснение как).

Та же запись, под каждыми 4 битами их 16-чная цифра:

a, b:
0111 1111
7 F
c:
0000 0000 0000 0000 0000 0000 0111 1111
0 0 0 0 0 0 7 F

Поскольку b положительное, старшие 3 байта c заполнятся 0: в c окажется 0x0000007F, поэтому программа напечатает 127.