Verschachtelte Strukturen, Union und Bitfelder

[Michael B. (Gast)]

Hallo zusammen,

habe ein Problem beim Anlegen eines verschachtelten Bitfeldes mit 
Strukturen und Union.

Ziel ist folgendes:
Das gesamte "Konstrukt" soll/darf nur 1 Byte groß sein.
Die Bits 5, 6 und 7 sind ein einzelne Bitfelder (hier: c, b und a).
Die Bits 0+1 (f) sowie 2+3+4 (e) bilden jeweils ein weiteres 
(Zahlen)Feld.
Diese, also die Bits 0 bis 4, sollen zeitgleich auch einen "Gesamtwert" 
repräsentieren (d). Alles zusammen ist eine Kenngröße (g).

Bits   7   6   5   4   3   2   1   0
     ----------------------------------
     |               g                |
     ----------------------------------
     | a | b | c |         d          |
     ----------------------------------
                 |     e     |    f   |
                 ----------------------

In C sieht das ganze bei mir so aus:

typedef union
{
  struct
  {
    uint8_t                a : 1;
    uint8_t                b : 1;
    uint8_t                c : 1;
    union
    {
      struct
      {
        uint8_t            f : 2;
        uint8_t            e : 3;
      };
      uint8_t              d : 5;
    }; 
  };
  uint8_t                  g;
}  TypeID;

Der so definierte Datentyp ist jedoch nicht 1 Byte, sondern 2 Byte groß 
(sizeof(TypeID))! :-O

Begründet liegt das irgendwie an dem inneren Union. Definiere ich das 
ganze so:

typedef union
{
  struct
  {
    uint8_t                a : 1;
    uint8_t                b : 1;
    uint8_t                c : 1;      
    uint8_t                d : 5; 
  };
  uint8_t                  g;
}  TypeID;

oder so

typedef union
{
  struct
  {
    uint8_t                a : 1;
    uint8_t                b : 1;
    uint8_t                c : 1;      
    uint8_t                f : 2;
    uint8_t                e : 3;
  };
  uint8_t                  g;
}  TypeID;

beträgt die Größe nur 1 Byte.
Klar kann ich jetzt Makros definieren um "d" maskieren und shiften um 
"e" und "f" zur erhalten, das Ganze allerdings direkt über einen Zugriff 
auf Variablen des Datentyps zu lösen ware mir um ein vielfaches lieber.

Wie bekomme ich denn den Datentyp auf 1 Byte !?

Danke für eure Hilfe!

Grüße
Michael

[A. S. (Gast)]

#pragma Pack, alignment oder ähnliches in deinem Compilerhandbuch 
nachschlagen.

Bei mir ist alles 1 Byte groß

[A. S. (Gast)]

Sorry, deine erste struct muss Union heissen.

Wenn du mit dem 4ten bit beginnen willst, dann 3bit ohne Namen 
reservieren.

[(prx) A. K. (prx)]

Ich würde in eine Bitfeld-Struct nicht noch eine weitere 
Bitfeld-Struct/Union schachteln.

[Michael B. (Gast)]

Achim S. schrieb:
> Sorry, deine erste struct muss Union heissen.
>
> Wenn du mit dem 4ten bit beginnen willst, dann 3bit ohne Namen
> reservieren.

Wie du meinen?

[Yalu X. (yalu) (Moderator)]

Mit dieser Deklaration werden beim GCC die Bitfelder so angeordnet, wie
du es dir vorstellst:

typedef union
{
  struct
  {
    union
    {
      struct {
        uint8_t  d : 5; // Bit 0..4
        uint8_t  c : 1; // Bit 5
        uint8_t  b : 1; // Bit 6
        uint8_t  a : 1; // Bit 7
      };
      struct
      {
        uint8_t  f : 2; // Bit 0..1
        uint8_t  e : 3; // Bit 2..4
      };
    }; 
  };
  uint8_t        g;     // Bit 0..8
} TypeID;

Ein Garantie, dass die Anordnung für einen anderen Compiler ebenso ist,
gibt es aber nicht.

Edit:

Die Größe eines Datentyps ist immer ein ganzzahliges Vielfaches eines
Bytes. Du hast aber wahscheinlich erwartet, dass das dein inneres Struct
nur 5 Bit groß ist.

[Mikro 7. (mikro77)]

#include <stdio.h>
#include <inttypes.h>

union U
{
  uint8_t g ;
  struct
  {
    uint8_t d : 5 ;
    uint8_t c : 1 ;
    uint8_t b : 1 ;
    uint8_t a : 1 ;
  } abcd ;
  struct
  {
    uint8_t f : 2 ;
    uint8_t e : 3 ;
  } ef ;
} ;

int main()
{
  union U u ;
  u.g = 0x5d ;
  printf("%ld\n",sizeof(u)) ;
  printf("%x %x\n",u.ef.e,u.ef.f) ;
  printf("%x %x %x %x\n",u.abcd.a,u.abcd.b,u.abcd.c,u.abcd.d) ;
  return 0 ;
}

Ausgabe:

1
7 1
0 1 0 1d

Imho kann der Compiler aber alles mögliche draus machen. Undefined 
Behavior (at least IB).

[(prx) A. K. (prx)]

Yalu X. schrieb:
> Ein Garantie, dass die Anordnung für einen anderen Compiler ebenso ist,
> gibt es aber nicht.

Bei einer big endian Maschine wird es so nicht funktionieren.

[(prx) A. K. (prx)]

Mikro 7. schrieb:
> Undefined Behavior (at least IB).

Grösstenteils implementation defined behavior.

[A. S. (Gast)]

Michael B. schrieb:
> Wie du meinen?


Ich sollte nie vom Handy schreiben...

Also: als erstes klären, ob er mit Bit0 oder mit bit7 anfängt.

typedef union
{
  struct
  {
    uint8_t                a : 1;
    uint8_t                b : 1;
    uint8_t                c : 1;
    uint8_t                d : 5;
  }a_d;
  
  struct
  {
      uint8_t              : 3;
      uint8_t            e : 3;
      uint8_t            f : 2;
  }ef;
  uint8_t                  g;
}  TypeID_MSBstart;


typedef union
{
  struct
  {
    uint8_t                d : 5;
    uint8_t                c : 1;
    uint8_t                b : 1;
    uint8_t                a : 1;
  }d_a;
  
  struct
  {
      uint8_t            f : 2;
      uint8_t            e : 3;
  }ef;
      
  uint8_t                  g;
}  TypeID_LSBstart;