zwei 8bit Werte in ein 16bit Wert umwandeln Warnung (C)

[Paul G. (paul_g210)]

Moin,

bitte entschuldigt wenn ich hier für einige Meister der Programmierung 
eine viel zu triviale Frage stelle und allein deswegen Spot, Empörung 
oder Belustigung auslöse. :D

Ich habe ein uint8_t Array der Größe zwei und ich möchte eine uint16_t 
Variable mit dem Inhalt des Arrays füllen.

Ich tat dies so:

uint8_t array[2] = {0x22, 0x66};
uint16_t b = array[0]<<8 | array[1];
printf("0x%04X\n", b);

--> 0x2266

Der Compiler warnt mich das:

Warnung: Umwandlung von »int« nach »uint16_t« {aka »short unsigned int«} könnte den Wert ändern [-Wconversion]

Kann ich die Warnung in diesem Fall einfach ignorieren weil der Compiler 
anscheinend nicht weiß das ich zwei uint8_t zu einem uint16_t vereinen 
möchte oder ist meine Umwandlung nicht gut gemacht und man macht das 
generell anders?

[Rolf M. (rmagnus)]

Das Problem liegt darin, dass die Integer-Promotion dazu führt, dass die 
Berechnung mit dem Typ int durchgeführt wird. array[0]<<8 kann dann aber 
zu einem negativen Wert führen. Du müsstest mindestens eines der beiden 
Elemente nach uint16_t casten, damit die Berechnung damit ausgeführt 
wird. Dann verschwindet auch die Warnung.

[A. S. (Gast)]

Es ist gut, dass Du Warnungen an hast und sie ernst nimmst.

Was hier passiert: integer promotion sorgt dafür, dass aus dem uint8 
beim schieben ein int wird.

Sauber wäre, dass Array-Element zuerst auf uint16 zu casten.

Hier stört es nicht, aber du solltest es wissen.

[Rolf M. (rmagnus)]

Felix schrieb im Beitrag #6576652:
> solche warnungen kannst du einfach deaktivieren. die stören nur beim
> coden.

Ja, kannste schon machen, aber dann ist es halt Sch****.

[Gerald K. (geku)]

Ein CAST könnte helfen :

uint8_t array[2] = {0x22, 0x66}; 

uint16_t b = (uint16_t)(array[0]<<8) | (uint16_t)array[1]; 
printf("0x%04X\n", b);

Schließlich sollte man wissen was der CAST bewirkt. Man gibt dem 
Kompiler bekannt, dass es sich rechts um zwei Variable vom Typ  uint16 
handelt. Der Kompiler gibt dann keine Warnung mehr aus. Det CAST muss 
link und rechts vom "oder" befindlichen Werte durchgefühert werden, 
damit schon uint16 Werte miteinander vorodert werden.

Warnungen generell abzuschalten ist keine gute Lösung.

[Paul G. (paul_g210)]

Rolf M. schrieb:
> Integer-Promotion


Danke euch, wieder was gelernt.

Gerald K. schrieb:
> Det CAST muss link und rechts vom "oder" befindlichen Werte durchgefühert 
werden,
> damit schon uint16 Werte miteinander vorodert werden.

Det mach ich so.

[dummtipper (Gast)]

eventuell hilft schon, ein U hinter die 8 zu schreiben

[A. S. (Gast)]

Gerald K. schrieb:
> Det CAST muss
> link und rechts vom "oder" befindlichen Werte durchgefühert werden,
> damit schon uint16 Werte miteinander vorodert werden.

Das ist nicht richtig, siehe

Rolf M. schrieb:
> Du müsstest mindestens eines der beiden
> Elemente nach uint16_t casten, damit die Berechnung damit ausgeführt
> wird. Dann verschwindet auch die Warnung.

Ein Problem ist, dass casts eigentlich böse sind. Sie schalten praktisch 
alle Warnungen ab.

Von daher kann es sinnvoll sein, hier ohne Integer-Promotion und ohne 
casts zu arbeiten. So bleibt Warnungen bei Flüchtigkeits-Fehlern 
trotzdem erhalten:

Variante 1: Hilfsvariable

uint16_t h = array[0];        
uint16_t b = h<<8 | array[1];

Variante 2: zweistufig

uint16_t b = array[0];        
b = h<<8 | array[1];

Variante 3: eine Verknüpfung mit 0U macht alles unsigned

uint16_t b = 0U | array[0]<<8 | array[1];

[Robinson Caruso (Gast)]

Wenn int auch 2 Byte groß ist, dann kann es schiefgehen. (Wenn die Zahl 
nicht mehr durch signed int dargestellt werden kann)

[A. S. (Gast)]

Robinson Caruso schrieb:
> Wenn int auch 2 Byte groß ist, dann kann es schiefgehen. (Wenn die Zahl
> nicht mehr durch signed int dargestellt werden kann)

was kann beim bisherigen Code schiefgehen und warum? Oder meinst Du wenn 
man andere Sachen (Vergleiche oder Dergleichen) macht?