4 Byte Array in long umwandeln

Oder mit Referenzierung/Dereferenzierung in einem Schritt:
Klappt aber nur, wenn die Endieness stimmt :)

1

long value = *(long*)&Array[0];

Ah sorry die Sprache ist C.
Diese Lösung ist mir auch schon eingefallen allerding sind das ja über 
50 Rechenoperationen das müsste doch mit Arrays oder Pointern eleganter 
gehen.

long value = *(long*)&Array[0];

Ich habe mich jetzt mal ein bischen in die PointerGeschichte eingelesen 
aber diese Anweisung versteh ich gar nicht. Wo wird denn gezeigt das der 
Wert Array[x] an die richtige stelle in dem long abgelegt wird.

Ein Array aus vier 8-Bit Variablen belegt im Speicher vier 
aufeinanderfolgende Bytes. Eine long-Variable belegt im Speicher vier 
aufeinanderfolgende Bytes.

Also ist es möglich, den Speicher bedarfsorientiert "anders" zu 
interpretieren, allerdings ist hier die Interpretation 
implementierungsabhängig, was an der "endianness" des Prozessors liegt.

Ein Array { 0x12, 0x34, 0x56, 0x78 } wird auf little-Endian-Prozessoren 
(u.a. Intel) als Long-Wert 0x78563412 interpretiert, auf 
big-Endian-Prozessoren (u.a. Motorola) hingegen als 0x12345678.

Timur Yigit wrote:
> long value = *(long*)&Array[0];
>
> Ich habe mich jetzt mal ein bischen in die PointerGeschichte eingelesen
> aber diese Anweisung versteh ich gar nicht. Wo wird denn gezeigt das der
> Wert Array[x] an die richtige stelle in dem long abgelegt wird.

gar nicht, das wird vorher schon gemacht

1

  unsigned char Array[4];

2

3

  Array[0] = erster_Wert_den_du bekommst;

4

  Array[1] = zweiter_Wert_den_du_bekommst;

5

  Array[2] = dritter_Wert_den_du_bekommst;

6

  Array[3] = vierter_Wert_den_du_bekommst;

7

8

  long value = *(long*)Array;

Der Trick besteht darin, dass bei einem Array die 4
Bytes im Speicher hintereinander abgelegt werden und
ein long ebenfalls aus 4 Bytes besteht.

Die letzte Anweisung, die mit dem Cast, sagt nichts
anderes als:
  * nimm die Startadresse des Arrays
    Array

  * und tu mal so, als ob diese Adresse die Adresse eines
    long wäre
    (long*)Array

  * von dieser angenommenen long-Adresse holst du jetzt
    mal den long Wert.
    *(long*)Array

Im Grunde trickst man den Compiler dahin, dass er die 4 Bytes
des Arrays als long auffasst und als long weiterbehandelt.


Allerdings muss die Reihenfolge der Bytes stimmen. Ob also
die Reihenfolge erster_Wert_..., zweiter_Wert_... etc.
richtig ist oder umgedreht werden muss, hängt davon ab in welcher
Reihenfolge der Sender die Bytes schickt und in welcher Reihenfolge
der Empfänger sie haben muss, damit wieder der korrekte Wert
herauskommt.

Timur Yigit wrote:
>>

1

>> long value = (unsigned long)(byte[0] << 24) | (byte[1] << 16) | (byte[2] << 8) | byte[3];

2

>>

> Diese Lösung ist mir auch schon eingefallen allerding sind das ja über
> 50 Rechenoperationen

Dann hast du den Optimizer deines Compilers nicht eingeschaltet.
Das sollten nicht wesentlich mehr als 4 Operationen sein, die
allesamt Register-Ladeoperationen sind.

Mit der Pointer-Geschichte ist es auf einem 32Bit Rechner nur eine 
32-Bit Lade-Operation.

Super Danke das habe sogar ich verstanden.

Sowas darf man nach C-Konvention nicht, bzw. das Ergebnis kann sich von 
Compiler zu Compiler und Zielplattform unterscheiden und hat 
möglicherweise nicht den gewünschten Effekt.

Mit anderen Worten:

Genau so macht man es.


Und bekommt Haarausfall, wenn man das funktionierende Programm auf eine 
andere Hardware portieren will, weil man diese Stellen auch nicht im 
Quelltext als problematisch oder "hic sunt dracones" gekennzeichnet hat.

Und dann kreischt und flucht man und postet interessante Vermutungen 
über Compilerfehler in irgendwelchen Foren ...

MNR wrote:
> Die union Lösung ist genauso gut oder schlecht, wie

1

long value =

2

> *(long*)Array;

 Wenn man Hardware-unabhängig bleiben will, müßte man
> nur die Indizes des Arrays per Macro umsortieren, dann läßt sich das
> leicht portieren.

Nein, um portabel zu bleiben musst du mehr machen. Ein char-Array muss 
nicht zwangsweise ausgerichtet sein im RAM. Es gibt aber CPUs, bei denen 
ein long ausgerichtet sein muss, sich also auf einer durch 4 teilbaren 
Adresse befinden muss. Auf so einem Rechner darfst du unter keinen 
Umständen ein nicht ausgerichtetes char-Array nach long casten, sonst 
stürzt das Programm einfach ab. Die Ausrichtung des char-Arrays kannst 
du mit Standard-Mitteln nicht hinbekommen.

Am sichersten ist es daher meiner Meinung nach, die Umwandlung zentral 
zu machen und eine Funktion zu schreiben:
long charsToLong(char blub[4]);

Dann hat man den mglw. unportablen Code wenigstens nur an einer Stelle. 
Ich würde aber dort einfach die Lösung mit bit-shifts nehmen. 
Schließlich geht es hier um ein PC- und nicht ein 
Mikrocontroller-Programm. Bei PC-Programmen spielt in erster Linie die 
Laufzeit-Klomplexität im Sinne der Landau-Notation eine Rolle, weniger 
die tatsächlichen konstanten Laufzeitunterschiede zwischen O(1) und O(1) 
(solange der Faktor nicht in die tausende geht, und je nach Kontext).