Что происходит с поразрядными операторами и целочисленным продвижением?

[expr.unary.op]

Операнд ~ должен иметь целочисленный или незаданный тип перечисления; результатом является единичное дополнение своего операнда. Выполняются комплексные рекламные акции.

[expr.shift]

Операторы сдвига << и >> группируют слева направо. [...] Операнды должны быть целочисленного типа или типа перечисления без области действия, и выполняются целые рекламные акции.

Что такое интегральное продвижение uint8_t (которое обычно будет unsigned_char за кулисами)?

[conv.prom]

Prvalue целочисленного типа, отличного от bool, char16_t, char32_t или wchar_t, чей ранг целочисленного преобразования (4.13) меньше ранга int, может быть преобразовано в prvalue типа int, если int может представлять все значения исходного типа. ; в противном случае исходное prvalue может быть преобразовано в prvalue типа unsigned int.

Итак, int, потому что все значения uint8_t могут быть представлены int.

Что такое int(12) << 1? int(24).

Что такое ~int(12)? int(-13).

По соображениям производительности языки C и C ++ считают int "наиболее естественным" целочисленным типом, и вместо этого типы, которые "меньше", чем int, считаются своего рода типом "хранилища".

Когда вы используете тип хранилища в выражении, он автоматически преобразуется в int или в unsigned int неявно. Например:

// Assume a char is 8 bit
unsigned char x = 255;
unsigned char one = 1;

int y = x + one; // result will be 256 (too large for a byte!)
++x;             // x is now 0

произошло то, что x и one в первом выражении были неявно преобразованы в целые числа, сложение было вычислено, а результат был сохранен обратно в целое число. Другими словами, вычисление НЕ было выполнено с использованием двух беззнаковых символов.

Точно так же, если у вас есть значение float в выражении, первое, что сделает компилятор, это повысит его до double (другими словами, float - это тип хранилища, а double - это естественный размер для чисел с плавающей запятой). Это причина, по которой, если вы используете printf для печати чисел с плавающей запятой, вам не нужно указывать %lf int строки формата, и %f достаточно (%lf требуется для scanf, однако, потому что эта функция сохраняет результат и float может быть меньше double).

C ++ немного усложнил дело, потому что при передаче параметров функциям вы можете различать int и более мелкие типы. Таким образом, не ВСЕГДА верно, что преобразование выполняется в каждом выражении ... например, вы можете иметь:

void foo(unsigned char x);
void foo(int x);

где

unsigned char x = 255, one = 1;
foo(x);       // Calls foo(unsigned char), no promotion
foo(x + one); // Calls foo(int), promotion of both x and one to int

Я тестировал большие числа, и оператор ‹< всегда дает мне положительные числа, а оператор ~ всегда дает мне отрицательные числа. Затем я использовал sizeof () и обнаружил ...

Неправильно, проверьте это:

uint8_t v = 1;
for (int i=0; i<32; i++) cout << (v<<i) << endl;

дает:

1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
262144
524288
1048576
2097152
4194304
8388608
16777216
33554432
67108864
134217728
268435456
536870912
1073741824
-2147483648

uint8_t - это 8-битный беззнаковый целочисленный тип, который может представлять значения в диапазоне [0,255], поскольку этот диапазон включен в диапазон int, он повышается до int (не unsigned int). Повышение до int имеет приоритет перед повышением до unsigned.

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

#include <cstdint>
#include <iostream>
#include <limits>
int main()
{
uint8_t x = 1;
int shiftby=0;
shiftby=8*sizeof(int)-1;
std::cout << (x << shiftby) << '\n'; // or std::cout << (x << 31) << '\n';

std::cout << ~x;

std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cin.get();
return 0;
}

Результат -2147483648

Обычно, если первый бит числа со знаком равен 1, это считается отрицательным. когда берешь большое количество и перекладываешь. Если вы сдвинете его так, чтобы первый бит был равен 1, он будет отрицательным.

** EDIT **
Ну, я могу придумать причину, по которой операторы сдвига будут использовать unsigned int. Рассмотрим операцию сдвига вправо >>, если сдвинуть вправо -12, вы получите 122 вместо -6. Это потому, что он добавляет ноль в начале без учета знака