Zugriff auf int-Variable über 8-bit Zeiger

Hallo!

Stellt euch bitte folgende Situation vor:

In einem IC gibt es ein 16-bit breites Konfigurationsregister, dass ich
über SPI auslesen möchte. Ich definiere mir also eine Integer-Variable,
in der ich diese Info abspeichern kann. Da ich über den SPI-Bus aber
nur 8 bit auf einmal empfangen kann, muss ich das Auslesen dieses
Registers auf 2 Anläufe staffeln.
Im ersten Anlauf lese ich z.B. das High-Byte und im zweiten das
Low-Byte. Die Frage lautet nun, wie ich die zwei gelesenen Bytes in
meine ursprünglich dafür vorgesehene Variable bekomme.

Ich habe vor kurzem ein Beispielprogramm gesehen, in dem folgendes
Konstrukt dafür verwendet wurde (auszugsweise):


int config_reg;

// Aufruf der Funktion, um das Konfigurationsregister auszulesen:
get_config_reg( (unsigned char*) &config_reg);


// Inhalt der Funktion:
void get_config_reg( (unsigned char*) &config_reg)
{
     spi_byte_1 = read_spi();    // Lies erstes Byte vom SPI-Bus
     config_reg[1] = spi_byte_1;
     spi_byte_2 = read_spi();    // Lies zweites Byte vom SPI-Bus
     config_reg[0] = spi_byte_2;
}


Mich würde jetzt interessieren, ob sowas einer "sauberen"
C-Programmierung entspricht? Mir ist schon klar, wie es funktioniert
und das es korrekt ist; ich habe so etwas in der Art aber zum ersten
Mal gesehen. Ich hätte es nämlich so gemacht:

int config_reg;

// Aufruf der Funktion, um das Konfigurationsregister auszulesen:
config_reg = get_config_reg();


// Inhalt der Funktion:
int get_config_reg()
{
     int ergebnis;

     ergebnis = read_spi();      // Lies erstes Byte vom SPI-Bus
     ergebnis = ergebnis >> 8;
     ergebnis |= read_spi();    // Lies zweites Byte vom SPI-Bus

     return ergebnis;
}


Beide Konstrukte liefern ja dasselbe Ergebnis.

Wie gesagt, würde mich aber interessieren, ob so etwas "sauber" und
gebräuchlich ist.

Vielen Dank schonmal für euere Beiträge!


Gruß
Thomas