Was ist mit bitweisen Operatoren und Integer-Promotion los?

Ich habe ein einfaches Programm. Beachten Sie, dass ich eine vorzeichenlose Ganzzahl mit fester Breite und einer Größe von 1 Byte verwende.

#include <cstdint>
#include <iostream>
#include <limits>

int main()
{
    uint8_t x = 12;
    std::cout << (x << 1) << 'n';
    std::cout << ~x;

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

    return 0;
}

Meine Ausgabe ist die folgende.

24
-13

Ich habe größere Zahlen und Operatoren getestet << gibt mir immer positive Zahlen, während Operator ~ gibt mir immer negative Zahlen. habe ich dann verwendet sizeof() und gefunden…

Wenn ich den bitweisen Linksverschiebungsoperator (<<), erhalte ich eine vorzeichenlose 4-Byte-Ganzzahl.

Wenn ich den bitweisen Not-Operator verwende (~), erhalte ich eine vorzeichenbehaftete 4-Byte-Ganzzahl.

Es scheint, dass der bitweise Not-Operator (~) führt eine vorzeichenbehaftete ganzzahlige Beförderung durch, wie es die arithmetischen Operatoren tun. Der Linksverschiebungsoperator (<<) scheint zu einem vorzeichenlosen Integral zu werden.

Ich fühle mich verpflichtet zu wissen, wenn der Compiler hinter meinem Rücken etwas ändert. Wenn ich mit meiner Analyse richtig liege, werden alle bitweisen Operatoren zu einer 4-Byte-Ganzzahl befördert? Und warum sind manche signiert und manche unsigniert? Ich bin so verwirrt!

Bearbeiten: Meine Annahme, immer positive oder immer negative Werte zu bekommen, war falsch. Aber da ich mich geirrt habe, verstehe ich, was wirklich passiert ist, dank der großartigen Antworten unten.

[expr.unary.op]

Der Operand von ~ muss einen ganzzahligen oder unbegrenzten Aufzählungstyp haben; das Ergebnis ist das Einerkomplement seines Operanden. Integrale Beförderungen werden durchgeführt.

[expr.shift]

Die Schichtoperatoren << und >> Gruppe von links nach rechts. […] Die Operanden müssen vom Aufzählungstyp ganzzahlig oder ohne Bereich sein und integrale Beförderungen durchgeführt werden.

Was ist die integrale Förderung von uint8_t (was normalerweise der Fall sein wird unsigned_char hinter den Kulissen)?

[conv.prom]

Ein prvalue eines ganzzahligen Typs außer bool, char16_t, char32_toder
wchar_t deren ganzzahliger Umwandlungsrang (4.13) kleiner ist als der Rang von
int kann in einen Prvalue vom Typ konvertiert werden int wenn int kann alle Werte des Quelltyps darstellen; andernfalls kann der Quell-prvalue in einen prvalue vom Typ konvertiert werden unsigned int.

So intweil alle Werte von a uint8_t vertreten werden kann durch int.

Was ist int(12) << 1 ? int(24).

Was ist ~int(12) ? int(-13).

Aus Performance-Gründen die Sprache C und C++ berücksichtigen int der “natürlichste” Integer-Typ zu sein und stattdessen Typen, die “kleiner” als an sind int gelten als eine Art „Speicher“-Typ.

Wenn Sie einen Speichertyp in einem Ausdruck verwenden, wird er automatisch in einen umgewandelt int oder zu einem unsigned int implizit. Beispielsweise:

// 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

Was passiert ist, ist das x und one im ersten Ausdruck wurden implizit in ganze Zahlen konvertiert, die Addition wurde berechnet und das Ergebnis wurde in eine ganze Zahl zurückgespeichert. Mit anderen Worten, die Berechnung wurde NICHT mit zwei Zeichen ohne Vorzeichen durchgeführt.

Ebenso, wenn Sie eine haben float Wert in einem Ausdruck wird der Compiler als erstes zu einem hochstufen double (mit anderen Worten float ist ein Speichertyp und double ist stattdessen die natürliche Größe für Fließkommazahlen). Dies ist der Grund, warum Sie verwenden printf Floats zu drucken braucht man nicht zu sagen %lf int die Formatzeichenfolgen und %f reicht (%lf wird benötigt für scanf aber weil diese Funktion speichert ein Ergebnis und ein float kann kleiner als a sein double).

C++ hat die Sache ziemlich verkompliziert, weil Sie beim Übergeben von Parametern an Funktionen unterscheiden können ints und kleinere Typen. Daher ist es nicht IMMER wahr, dass in jedem Ausdruck eine Konvertierung durchgeführt wird … zum Beispiel können Sie haben:

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

wo

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

Ich habe größere Zahlen getestet und der Operator << gibt mir immer positive Zahlen, während der Operator ~ mir immer negative Zahlen gibt. Ich habe dann sizeof() verwendet und gefunden ...

Falsch, teste es:

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

gibt:

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 ist ein 8 Bit langer vorzeichenloser Ganzzahltyp, der Werte im Bereich darstellen kann [0,255]da dieser Bereich im Bereich von enthalten ist int es wird gefördert int (nicht unsigned int). Beförderung zu int hat Vorrang vor der Beförderung zu unsigned.

Einblick in Zweierkomplement und wie der Computer negative ganze Zahlen speichert.
Versuche dies

#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;
}

Die Ausgabe ist -2147483648

Wenn das erste Bit einer vorzeichenbehafteten Zahl 1 ist, wird dies im Allgemeinen als negativ angesehen. wenn Sie eine große Zahl nehmen und verschieben. Wenn Sie es so verschieben, dass das erste Bit 1 ist, wird es negativ

** BEARBEITEN **

Nun, ich kann mir einen Grund vorstellen, warum Shift-Operatoren unsigned int verwenden würden. Betrachten Sie den Rechtsverschiebungsbetrieb >> Wenn Sie nach rechts verschieben, erhalten Sie -12 122 statt -6. Dies liegt daran, dass am Anfang eine Null hinzugefügt wird, ohne das Vorzeichen zu berücksichtigen