Bit Manipulationene

[severin (Gast)]

Hallo
~~~~~

Ich hoffe es kann mir jemand helfen.
Ich komme mit Bit Manipulationen an so einer Typumwandlung nicht ganz
klar.
Kann mir an Hand dieses Beispiels jemand erklären, wie es
funktioniert?

uInteger = 0xFFFF;

ucChar1((unsigned char)(uInteger>>8));
ucChar2((unsigned char)uInteger);

Danke.

[Werner B. (Gast)]

Mal angenommen...

unsigned int uInteger;
unsigned char ucChar1, ucChar2;

dann ...

uInteger = 0xFFFF;

ucChar1 = (unsigned char)(uInteger>>8);
ucChar2 = (unsigned char)uInteger;

Wo ist das Problem?

[marcel (Gast)]

kurze c einführung:
-also "int" hat 2 Bytes, "char" hat 1 Byte.
-"unsigned" sagt dass es eine vorzeichenlose variable ist
-ein cast "interpretiert" den wert nicht, sondern nimmt den inhalt,
der an der adresse steht und "denkt" es sei der typ, der bei mcast
angegeben wurde.
- x >> n bedeutet, dass x um n stellen nach rechts geschoben (nicht
rotiert!) wird.

nun zum Beispiel oben:

uInteger scheint ein unsigned int zu sein.
zu ucChar1 (von innen nach außen): uInteger um 8 Stellen nach rechts
schieben (also das letzte Byte/letzten beiden Hex-Stellen streichen)
und dann als ein byte behandeln
zu ucChar2: den wert von uInteger als ein byte (unsigned char)
betrachten (das vordere byte streichen).

Für die Bit-Manipulation kannst du dir einfach folgendes merken:
x |=  (1 << n)    "oder ist": setze bit n in variable x
x &= ~(1 << n)    "und ist" mit komplement ("~"): lösche bit n in
variable x
x ^=  (1 << n)    "xor ist": schalte bit n in variable x um (in den
entgegengesetzten zustand)
x & (1 << n)     test, ob bit n in variable x gesetzt


also nun ein beispiel:
~(   0101 1010)   (0x5A)
=    1010 0101   (0xA5)

     0101 1010   (0x5A)
|=   0010 0000   (1 << 5) = (0x20)
---------------
     0111 1010

     0101 1010   (0x5A)
&=   0000 1000   (1 << 3) = (0x04)
--------------
     0000 1000

     0101 1010   (0x5A)
&=   1110 1111   ~(1 << 4) = (0xef)
--------------
     0100 1010

     0101 1010   (0x5A)
^=   1000 0000   (1 << 7) = (0x80)
--------------
     1101 1010

     1101 1010
^=   1000 0000   (1 << 7) = (0x80)
--------------
     0101 1010

[OldBug (Gast)]

Daß ein integer (int) zwei Bytes hat, ist aber nicht C-Spezifisch,
sondern Architekturbedingt! Auf 32-Bit-Prozessoren ist

    sizeof(int) == 4!

[severin (Gast)]

Danke!

Wie dieses Verfahren funktioniert ist mir jetzt klar geworden.

[marcel (Gast)]

das ist mir schon klar, aber ein 4 byte oder 8 byte (wie es mal für die
64bit prozessoren angedacht war - aber nicht gemacht wurde) int auf
einem microcontroller ist recht unwahrscheinlich...

Oder hier ist einer Selbstmordgefährtet und fängt gleich mit 32 bit
microcontrollern an... ;)

[OldBug (Gast)]

Man nehme zum Beispiel einen ARM7 (zb LPC2106)...

Aber das spielt ja auch keine Rolle, ich wollte auf Deine "fehlerhafte
Einführung in C" hinweisen ;-)

[marcel (Gast)]

ok, danke.
hinweis zur kenntnis genommen... .)