Bitshift: Byte in 32 Bit Variable

Horst Gast #3496329
Lesenswert?
• ▲
▼ 
Hallo, ich habe eine einfache Frage, eigentlich nur, weil mein Compiler 
mich mit seiner Warnung etwas verwirrt:

Ich habe eine 32 Bit Variable und eine 8 Bit Variable. Nun möchte ich 
die 8 Bit-Variable an verschiedene Stellen der 32-Bit-Variable schieben, 
im Prinzip diese Byteweise auffüllen, von MSB nach LSB.

Dafür hatte ich

1
uint32_t 32bit_var = 0;

2
uint8_t 8bit_var = 0xFF;

3


4
32bit_var = (8bit_var <<16);


geshiftet, um die 8bit-variable an die zweite Byte-Stelle zu schieben:
32 Bit variable:
| 1. Byte | 8bit_var | 3. Byte | 4. Byte |

Mein Compiler sagt mir aber nun:

"Left shift count >= width of type"

Stimmt meine aktion oben oder habe ich einen Fehler gemacht?
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Frank M. Moderator Persönliche Seite #3496336
Lesenswert?
• ▲
▼ 
Versuchs mal so:

1
32bit_var = ((uint32_t) 8bit_var <<16);


> Mein Compiler sagt mir aber nun:
>
> "Left shift count >= width of type"

Standardmäßig werden Ausdrücke vom Compiler in "int"-Größe "berechnet". 
Bei einem µC sind das i.d.R. 16 Bit. Wenn Du aber den Wert bereits um 16 
Bit shiftest, bist Du über die Größe eines "int" bereits hinaus.

P.S.
Ich habe bisher noch keinen C-Compiler gesehen, der Ziffern als erstes 
Zeichen in Variablennamen erlaubt ;-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Holger S. #3496344
Lesenswert?
• ▲
▼ 
Versuch mal
1
32bit_var = 8bit_var; 

2
32bit_var = 32bit_var << 16;

ich hab' gerade ein ähnliches Problem & hier erfahren, dass der ein- 
oder andere Compiler erst bei der Zuweisung auf den Zieltyp castet. 
Demnach könnte deiner versuchen, die 8 Bit Variable um 16 Bit zu shiften 
& die Warnung wäre nicht unbegründet :-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Horst Gast #3496351
Lesenswert?
• ▲
▼ 
Das wird dann wohl so funktionieren.
Was ich ehrlich gesagt aber noch nicht ganz verstehe: Wenn ich in einen 
32Bit int caste, habe ich doch im Prinzip eine 32 Bit-Variable mit dem 
8Bit wert in den letzten 8 Stellen und davor Nullen.

Wenn ich diese nun shifte und in meine 32Bit-variable schreibe, die ich 
in mehreren Schritten füllen möchte (sagen wir zB mit einem 16 Bit ADC 
wert aus einer L und H variable) - überschreibe ich dann nicht die 
anderen stellen mit nullen aus der gecasteten variable? also habe ich im 
beispiel oben dann nicht

| 0x00 | 8bit_var | 3. Byte | 4. Byte |

Als ergebnis, auch wenn vorher in Byte 1 etwas anderes stand?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Oliver Gast #3496365
Lesenswert?
• ▲
▼ 
Holger Schneider schrieb:
> ich hab' gerade ein ähnliches Problem & hier erfahren, dass der ein-
> oder andere Compiler erst bei der Zuweisung auf den Zieltyp castet.

Bei den "ein- oder anderen Compilern" handelt es sich um 100% aller C- 
und C++ - Compiler. Denn dieses Verhalten ist eindeutig den 
Sprachstandards so definiert. Sollte sich ein Compiler nicht daran 
halten, ist es auch kein C/C++-Compiler.

Oliver
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren