Nur ein Byte aus einem 32Bit-Wort herausziehen - wie am besten?

[Hans (Gast)]

Hi zusammen!

Ich habe ein Datenwort mit 32Bit Länge - das möchte ich nun in Bytes 
umbasteln.

Hier gibt es ja mehrere Möglichkeiten, mit Pointer und ohne - der 
Einfachheit halber lieber ohne Pointer. Aber hier gehen ja auch noch 
verschiedene Sachen...

Also:

uint32_t data = 83749; // nur als Beispiel
uint8_t bytes[4];

// Variante 1:

bytes[0] = (uint8_t) (data >> 24);
bytes[1] = (uint8_t) (data >> 16);
bytes[2] = (uint8_t) (data >> 8);
bytes[3] = (uint8_t) data;

// Variante 2:

bytes[0] = (data >> 24) & 0xFF;
bytes[1] = (data >> 16) & 0xFF;
bytes[2] = (data >> 8) & 0xFF;
bytes[3] = data & 0xFF;

// geht auch sowas:

bytes[0] = (data & 0xFF000000);
bytes[1] = (data & 0xFF0000);
bytes[2] = (data & 0xFF00);
bytes[3] = data & 0xFF;

Oder gibt es eine noch bessere Möglichkeit?

[Tip (Gast)]

Du könntest eine union anlegen und kommst dann evtl. einfacher ans Bit 
ran. Das kommt auf den Kontext an, d.h. wonach bestimmt sich das Bit und 
wohin soll es, wenn du es rausgezogen hast.

mfg

[Nico S. (Gast)]

eine Union!

union
{
    uint32_t zahl;
    uint8_t byte[4];
} uni;

int main(void) {
    uni myvar;
    myvar.zahl = 30923;

    if(myvar.byte[1] == 5) { }
    return 0;
}

[Werner B. (werner-b)]

Das funktioniert jedenfalls nicht !

/* FALSCH ! */
bytes[0] = (data & 0xFF000000);
bytes[1] = (data & 0xFF0000);
bytes[2] = (data & 0xFF00);

Müsste so aussehen:

bytes[0] = (data & 0xFF000000) >> 24;
bytes[1] = (data & 0xFF0000) >> 16;
bytes[2] = (data & 0xFF00) >> 8;

Und dann gibt es da noch die "Edianness" zu berücksichtigen.
http://en.wikipedia.org/wiki/Endianness
bzw.
http://de.wikipedia.org/wiki/Endianness

[Michael H. (morph1)]

Die muss er nur berücksichtigen wenn er ein Union verwendet, beim 
Shiften und Maskieren kann ihm die egal sein.

[Hans (Gast)]

OK, vielen Dank schonmal!

Ist denn zwischen den beiden

// Variante 1:

bytes[0] = (uint8_t) (data >> 24);
bytes[1] = (uint8_t) (data >> 16);
bytes[2] = (uint8_t) (data >> 8);
bytes[3] = (uint8_t) data;

// Variante 2:

bytes[0] = (data >> 24) & 0xFF;
bytes[1] = (data >> 16) & 0xFF;
bytes[2] = (data >> 8) & 0xFF;
bytes[3] = data & 0xFF;

ein Unterschied, weshalb das eine dem anderen vorziehen sollte?

[Hans (Gast)]

Man kann das 0xFF ja theoretisch auch weglassen und das umcasten ebenso.

[(prx) A. K. (prx)]

Was spricht gegen:

bytes[0] = data >> 24;
bytes[1] = data >> 16;
bytes[2] = data >> 8;
bytes[3] = data;

wenn man mal davon ausgeht, dass ein Byte 8 Bits hat?

Ein nicht zu dämlicher Compiler wird daraus Code erzeugen, der nicht 
schlechter ist als der Weg über eine Union, oft hingegen besser.

[Klaus (Gast)]

Hans schrieb:
> OK, vielen Dank schonmal!
>
> Ist denn zwischen den beiden// Variante 1:
>
> bytes[0] = (uint8_t) (data >> 24);
> bytes[1] = (uint8_t) (data >> 16);
> bytes[2] = (uint8_t) (data >> 8);
> bytes[3] = (uint8_t) data;
>
> // Variante 2:
>
> bytes[0] = (data >> 24) & 0xFF;
> bytes[1] = (data >> 16) & 0xFF;
> bytes[2] = (data >> 8) & 0xFF;
> bytes[3] = data & 0xFF;
> ein Unterschied, weshalb das eine dem anderen vorziehen sollte?

Ich hatte mit einem DSP zu tun der mit 16-Bit je Adresse gearbeitet hat. 
Dadurch ist 16-Bit die kleinste addressierbare Einheit. Ein unsigned 
char war zwar sizeof(unsigned char)=1 aber mit 16-Bit Wertebereich. 
Variante 1 hätte auf dieser Plattform nicht das gewünschte Ergebnis 
geliefert (ich habe stundenlang nach dem Fehler gesucht: Der Cast nach 
unsigned char hat hier 16-Bit stehen lassen).

Ich persönlich nutze seither immer Variante 2, auch wenn ich der Meinung 
bin das das beobachtete Verhalten mehr ein Compilerproblem war...

[Werner B. (werner-b)]

Es gab/gibt eine AVR-GCC Version (fragt bitte nicht welche) die

bytes = (ulong & 0xFF000000UL) >> 24;

in ein elegantes "move byte from register to register" übersetzt hat, 
und

bytes = ulong >> 24;

in eine Schleife mit 24 shift Operationen quer durch vier Bytes.

Darum habe ich mir das gemerkt und prüfe (fast) immer was der Compiler 
aus der jeweiligen Version macht.