Serialisierung von Datenstrukturen in C

Hallo,
dies ist mein erster Beitrag in diesem Forum...
Ich hab eine Aufgabe (C Programmierung) zu lösen mit der ich ganz und garnicht zurecht komme, vielleicht könnt ihr mir da helfen. Hier die Aufgabe:

typedef enum {
  Stop = 0,
  Start = 1,
  Finish = 5,
  Fail = 255
} Status;

typedef enum {
  One = 1,
  Fifteen = 15,
  Last = 255
} Numbers;

/**
   @brief Aufgabe1b: Serialisierung von Datenstrukturen
   @param [in] Status s
   @param [in] Numbers n
   @param [out] short int* data  

Gegeben sind zwei enums. Ihre Aufgabe ist es jeweils Werte der 
beiden enums in ein Datenpacket der Groesse 16Bit zu packen (serialisieren).
Werte des enums Status sollen dabei in das Low Byte und Werte
des enums Numbers sollen in das High Byte gepackt werden.
*/

void serialize(Status s, Numbers n, short int* data) {
  // Ihre Loesung
}

CJosef

Hi
Thema Bitshift sollte helfen.

ok, das ist ein Ansatz mit dem ich wenigstens ein bischen was anfangen kann.

data = (n << 8) + (s >> 8);

könnte das dann schon so richtig sein? kann ich das enum einfach so verschieben, oder muss ich das irgendwie mit ner schleife durchlaufen und die werte einzeln verschieben?

SeppJ

Nicolai schrieb:

data = (n << 8) + (s >> 8);
könnte das dann schon so richtig sein?

Noch nicht. Denk noch mal genau nach und guck dir notfalls nochmal an, wie das mit der Bitschieberei geht. Außerdem: Pointer!

kann ich das enum einfach so verschieben, oder muss ich das irgendwie mit ner schleife durchlaufen und die werte einzeln verschieben?

Wie? Welche Werte? Eine enum-wertige Variable hat nur einen Wert (aus einer Anzahl möglicher Werte). Was meinst du genau?

hm, ich fürchte ich hab das mit den enums noch nicht ganz verstanden.
ich dachte das wäre so ne art "mini-klasse" und

Stop = 0,
Start = 1,
Finish = 5,
Fail = 255

wären sowas wie variablen..

"Ihre Aufgabe ist es jeweils Werte der beiden enums in ein Datenpacket der Groesse 16Bit zu packen"
welches sind denn jetzt die werte? stop, start, finish und fail, oder 0, 1, 5, 255?

SeppJ

Nicolai schrieb:

hm, ich fürchte ich hab das mit den enums noch nicht ganz verstanden.
ich dachte das wäre so ne art "mini-klasse" und

Stop = 0,
Start = 1,
Finish = 5,
Fail = 255

wären sowas wie variablen..

Nein, das stimmt überhaupt gar nicht. Nimm dir nochmal dein Lehrbuch vor.

Die Kurzerklärung ist, dass ein enum ein Typ (wie int, double, void*, usw.) ist. Variablen dieses Typs können nur bestimmte Werte (hier: Stop, Start, Finish, Fail) annehmen. So wie ein int nur Ganzzahlen speichern kann, ein char nur Zeichen oder ein void* nur Zeiger speichern kann. Diese Werte (Stop, Start, Finish, Fail) haben auch eine Repräsentation als Zahl (so wie alles in einem Computer), die Werte sind hier 0, 1, 5 und 255.

aaah ich glaub jetzt hab ich das verstanden.

void serialize(Status s, Numbers n, short int* data) {
}

also haben die parameter s und n bereits EINEN festen wert, zb 0 oder 1.
und ich dachte da wäre das komplette enum drin, also zb

typedef enum {
  Stop = 0,
  Start = 1,
  Finish = 5,
  Fail = 255
} Status;

das war auch etwas was für mich überhaupt kein sinn gemacht hat. wie nämlich das enum (was ja theoretisch auch viel mehr "Werte" enthalten kann, in eine 16bit große int-variable passt.

jetzt fehlt also nur noch das shiften.
*data = irgendwas.

ich musste auch ne aufgabe machen die das low und high byte eines short int variable tauscht.

short int switchLowHighByte(short int i) {
	return ((0xFF00 & i) >> 8) + ((0x00FF & i) << 8) ;
}

also könnte das ergebnis so aussehen:

*data = ((0xFF00 & s) >> 8) + ((0x00FF & n) << 8) ;

ist es so besser?

ach ja:
mein "Lehrbuch" (Vorlesungs-skript) ist keine große hilfe, sonst wäre ich ja nicht hier. Da steht nur die syntax von den enums, aber null erklärung

SeppJ

Nicolai schrieb:

ach ja:
mein "Lehrbuch" (Vorlesungs-skript) ist keine große hilfe, sonst wäre ich ja nicht hier. Da steht nur die syntax von den enums, aber null erklärung

Dann könntest du dir ein gutes Buch holen, wenn es dich interessiert. Siehe Sticky-Threads hier im Forum.

Nicolai schrieb:

ich musste auch ne aufgabe machen die das low und high byte eines short int variable tauscht.
short int switchLowHighByte(short int i) {
	return ((0xFF00 & i) >> 8) + ((0x00FF & i) << 8) ;
}
also könnte das ergebnis so aussehen:
*data = ((0xFF00 & s) >> 8) + ((0x00FF & n) << 8) ;
ist es so besser?

Vertauschen ist eine leicht andere Aktion als du hier vor hast. Ich male mal ein "Bildchen":

Wert S:         SSSSSSSS
Wert N:         NNNNNNNN
Ziel  : ZZZZZZZZZZZZZZZZ
Was musst du nun wie verschieben, um den Ziel den Wert
Ziel  : NNNNNNNNSSSSSSSS
zu geben?

so, ich habs jetzt hingekriegt.

void serialize(Status s, Numbers n, short int* data) {
   *data = (n << 8) + s;
}

deprimierend, das es so einfach aussieht, aber ich wochen dranhocke und keinen schimmer hab. Vielen Dank SeppJ und CJosef.

Wutz

Der Lesbarkeit wegen sollte es unsigned short sein statt short int, und wenn du sowie mit Bitoperationen rumhantierst bietet sich hier | statt + an.

CJosef

Die Werte addieren dürfte in vielen Fällen falsche Ergebnisse liefern.
Ein bitweises Oder hilft aus dem Schlamassel.