Verständtnis C-Code Bitmanipulation

[Sawyer M. (sawyer_ma)]

Hallo alle zusammen,

ich verstehe gerade meinen eigenen Code in C nicht. Bei der 
Bitverschiebung können Bits eines Wertes nach links oder rechts 
verschoben werden. Gut das habe ich hier getan.

for(int x=0;x<10;x++){
  int c = x << 1;
  int b = c << 2;
  printf("%d\n",b);
}

Nach logischer Überlegung kam ich bei den Schritten auf folgendes 
Ergebnis:

1.) 0000 => C= 0000 => b = 0000 Ausgabe b = 0
2.) 0001 => C= 0010 => b = 1000 Ausgabe b = 8
3.) 0010 => C= 0100 => b = 0000 Ausgabe b = ?? Mein Ergebnis ist b = 1

usw.

die ganze Zahlenkette ist laut Programm 0, 8, 16, 24, 32, 40, 48, 56, 
64, 72 jedoch verstehe ich nicht warum??

Warum wird im 3 Schritt anstatt meiner berechneten 1 eine 16 
ausgegeben??
Was macht meine Schleife denn da??

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ein Integer hat nicht nur 4, sondern mindestens 16 oder gar 32 Bits...

[lambda (Gast)]

Du gehst bei dir von lediglich 4 Bit für Int aus, Int ist aber deutlich 
größer, häufig 16 oder 32 Bit. Das heißt dein Überlauf kommt erst 
deutlich später.
x ist im dritten Schritt 2, damit ist c = 4 (x*2) und b = 16 (c*4).

[Frank (Gast)]

Verschoben um 1 ist Multiplikation mit 2.
Sprich in c steht 0,2,4,8...
Verschoben um 2 ist Multiplikation mit 4.
Sprich in int b steht int c*4 oder x*8.
In Zahlen 0,8,16,24...

[Sina A. (sinapse)]

aber selbst bei 4bit... wie kommst du zum schluss auf b=1?

[Sawyer M. (sawyer_ma)]

Ok, ja das ist mir bekannt. Aber dann versteh ich nicht wieso mein 
zweiter Wert 8 ist?? Springt der immer in 4er Päckchen??

Also Anfangs 0000 wenn die voll sind werden weitere vier nullen 
angehangen also 0000 0000 usw.??

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Und zudem ist der << kein Rotationsoperator. Deshalb kommt nach dem 
Hinausschieben der 1 immer eine 00000000...00 heraus.

[Stefan F. (Gast)]

3.)  x=0000000000000010
     c=0000000000000100
     b=0000000000010000   und das ist eben 16 in dezimal

Auch ich frage:
> wie kommst du zum schluss auf b=1?

Las ich raten: Du gehst davon aus, dass die Bits, die links heraus 
fallen, wieder von Rechts herein kommen. Das ist aber nicht der Fall. Du 
verwechselst hier das "schieben" mit "rotieren". Zum Rotieren von Bits 
hat allerdings IMHO die Sprache C keinen Operator. In Assembler würde 
das gehen.

[Sawyer M. (sawyer_ma)]

Ach du Scheiße, vielen Dank. :D ich habe mich selbst ausgetrickst. Der 
Code sollte so heißen:

for(int x=0;x<10;x++){
  int c = x << 1;
  int b = c >> 2;
  printf("%d\n",b);
}

[Stefan F. (Gast)]

> werden weitere vier nullen angehangen also 0000 0000 usw.??

Nein, "normale" Integer Variablen haben bei dieser Hardware-Architektur 
immer 16 Bits. Egal, welcher Wert da drin steht.

[Sawyer M. (sawyer_ma)]

Vielen Dank für eure Hilfe. Leider war es ein klassischer Tippfehler. 
Trotzdem waren eure Antworten sehr hilfreich :)

[Stefan F. (Gast)]

> Der Code sollte so heißen:

Was soll das werden?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Stefan U. schrieb:
> bei dieser Hardware-Architektur
Bei welcher?

[Markus F. (mfro)]

Stefan U. schrieb:
> Zum Rotieren von Bits
> hat allerdings IMHO die Sprache C keinen Operator. In Assembler würde
> das gehen.

Das geht auch mit C. Ein einigermassen intelligenter Compiler erkennt, 
was Du haben willst. Mein (schon relativ betagter) m68k-gcc macht 
beispielsweise aus

uint32_t rol32(uint32_t x, uint32_t n)
{
    return (x << n) | (x >> (32 - n));
}

das da:

00000154 <_rol32>:
     154:  202f 0004        movel %sp@(4),%d0
     158:  222f 0008        movel %sp@(8),%d1
     15c:  e3b8             roll %d1,%d0
     15e:  4e75             rts

Wenn ich noch ein inline dazupacke, steht nur noch das roll da.