Печатает 7, 3.5 и 3.
static_cast<double>(value) создаёт выражение типа double для первого деления.
Тип и сохранённое значение переменной value типа int не меняются.
Во втором делении по-прежнему используются целые числа, поэтому результат — 3.
Перед делением оба операнда приводятся к одному числовому типу.
Один операнд уже имеет тип double, поэтому второй автоматически преобразуется в double.
Используемые здесь значения типа int помещаются в double, поэтому их значения сохраняются.
Компилятор выполняет преобразование, равнозначное static_cast<double>(2), как при преобразовании меньшего
целочисленного типа в больший.
Если записать оба преобразования явно, первое деление выглядит так:
static_cast<int> здесь произойдет даже если его не написать.
Так как любое число, сохраненное в a, всегда влезет в b,
можно просто присвоить к b переменную a,
что совершит конверсию из uint8_t в int автоматически.
Как и в прошлом примере, конверсия произойдет автоматически даже без static_cast,
потому что любое число, сохраненное в a, влезет в b.
Конверсия сохраняет значение, а значит и знак:
раз a отрицательное, верхние биты b заполнятся 1.
-3 это 1111 1101 в 8 битах
и 1111 1111 1111 1111 1111 1111 1111 1101 в 32 битах.
Выполнение по шагамЧто делает static_cast<uint8_t>?
В данном примере, он берет только младший байт числа от a,
отсекая старшие 3 байта. Это называется truncation.
Если записать это без static_cast<uint8_t>,
по умолчанию он произойдет автоматически.
При этом компилятор не дает ошибок,
если не переданы флаги предупреждения при компиляции.
Чтобы подобные ситуации определялись и останавливались компилятором,
необходимо передать флаги предупреждений, компилируя, например, вот так:
g++ test.cpp -Wall -Werror -Wconversion
Помимо этого, можно использовать инициализацию через фигурные скобки.
Следующее тоже не скомпилируется:
uint8_tb { 256 }; // сужающее преобразование
А следующее вероятно даст предупреждение:
uint32_ta { 256 };
uint8_tb { 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 при отсечении.
Отрицательные числа обрезаются так же: остаётся только последний байт.
-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 как символ.
Это побитовый оператор, который переделывает все 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.
В данном примере, он воспринимает представление числа сохраненное в 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.