struct über ein byte-array legen

[Simon K. (simon)]

Huhu,

Ich benutze folgendes Konstrukt, um ein 512-Byte Puffer zu erhalten und
wahlweise 3 verschiedene "Schablonen" darauf aufzulegen.

  u08 buffer[512];
  struct t_dirdata *p_dirdata = (struct t_dirdata *) &buffer;
  struct t_filedata *p_filedata = (struct t_filedata *) &buffer;
  struct t_headerpage *p_headerpage = (struct t_headerpage *) &buffer;

Ich denke mal ihr wisst was ich meine.

Nunja, da das ganze sehr verwirrend aussehen kann, wollte ich frage, ob
man das nicht irgndwie anders realisieren könnte.

Vielen Dank schonmal

[Karl H. (kbuchegg)]

Kann man (wenn auch nicht standardkonform (*)

union Data {
  t_dirdata    DirData;
  t_filedata   FileData;
  t_headerpage HeaderPage;
};

Davon eine Variable gemacht:

union Data Daten;

und schon teilen sich
  Data.DirData
  Data.FileData
  Data.HeaderPage

ein und denselben Speicher. Sie liegen quasi übereinander.

(*)
Das ist deshalb nicht standardkonform, weil du vom C Standard
nur die Zusicherung kriegst, dass du Daten aus einer Union
nur über den gleichen Weg wiederlesen kannst über den sie
auch geschrieben wurden. In der Praxis funktioniert obiges
allerdings auf allen Compilern die ich kenne.

Ach ja: Wenn du magst kannst du ja auch noch zusätzlich das
512-er Buffer Array in die union mit aufnehmen.

[Simon K. (simon)]

Vielen Dank schonmal für deine Antwort!.

Die Möglichkeit sieht wirklich schon zivilisierter aus. Ich denke mal
so werde ich das machen

[Simon K. (simon)]

Nochmal eine Frage,
Kann es sein, dass wenn die Structs, die in der Union sind,
gleichnamige member haben, es Probleme geben kann?

Folgende Meldung spuckt der Compiler bei folgendem Code aus:

//Header-page on disk
struct t_diskheader
{
  u08 diskname[64];  //Name of disk
  u32 p_root;      //Pointer to root-dir
  u32 disksize;    //size of disk in kb
};

//a headerpage is a page, which contains file-/dirheader-information
only
struct t_headerpage
{
  u32 p_nextpage;    //pointer to next page in chain
  u16 validbytes;    //# of valid bytes in this page
  u16 hdrreserved;  //2 bytes reserved

  u32 tcreate;    //time of creation
  u32 tlastaccess;  //time of last access
  u32 tlastchange;  //time of last change
  u08 objname[256];  //256-char name of file/dir
  u32 p_parent;    //pointer to parent dir
  u08 headertype;    //0 = DIR, 1 = FILE
  u08 attribflags;  //Atrribute of file/dir
  u32 filesize;    //size of file (if dir, then filesize = 0!)
  u08 reserved[226];  //Reserved
};

//t_dirdata is a page, which contains 126 dir entrys
struct t_dirdata
{
  u32 p_nextpage;    //pointer to next page in chain
  u16 validbytes;    //# of valid bytes in this page
  u16 hdrreserved;  //2 bytes reserved

  u32 dir_entry[126];  //holds pointer to linked dir/file. max 126
};

//t_filedata is a page, which holds 504b filedata
struct t_filedata
{
  u32 p_nextpage;    //pointer to next page in chain
  u16 validbytes;    //# of valid bytes in this page
  u16 hdrreserved;  //2 bytes reserved

  u08 data[504];    //504b + 8 bytes header = 512byte
};

//Union of one page.
union u_page
{
  u08 raw[512];
  struct t_filedata;
  struct t_dirdata;
  struct t_headerpage;
  struct t_diskheader;
};

error C2020: 'p_nextpage' : 'union' member redefinition
error C2020: 'validbytes' : 'union' member redefinition
error C2020: 'hdrreserved' : 'union' member redefinition

Ist es vielleicht sinnvoll, eine neue struct mit den jeweils 3 gleichen
membern zu machen und diese jeweils in die structs t_headerpage,
t_dirdata und t_filedata einzubeziehen?

[Rufus Τ. F. (rufus)]

Du solltest keine anonymen Elemente in der Union verwenden. Also nicht

union u_page
{
  u08 raw[512];
  struct t_filedata;
  struct t_dirdata;
  struct t_headerpage;
  struct t_diskheader;
};

sondern

union u_page
{
  u08 raw[512];
  struct t_filedata filedata;
  struct t_dirdata dirdata;
  struct t_headerpage headerpage;
  struct t_diskheader diskheader;
};

[Simon K. (simon)]

ah klatsch. Das habe ich übersehen :-) Die Elemente in der Union
müssen ja schließlich einen Namen haben, damit man sie ansprechen
kann.

Dank dir Rufus!