Was fuer "großes" Bit ist das denn ??????

[Siro]

struct
{
  int b1 : 1;
  int b2 : 1;
} bitField;

int main(void)
{ 
  
  bitField.b1 = 2147483647;  /* kein Warning */

Mein IAR-Compiler erkennt hier garkein Problem, kein Warning, garnichts.....
Das heisst in einer Bitdefinition ein Bit setzen möchte, kann ich irgend eine Zahl zwischen 1 + 2147483647 angeben, sofern mein int ein 32 Bit ist. Bei größeren Werten meckert er zumindestens an, daß sich das Vorzeichen meines einzelnen Bits ändern könnte
Na wenn das nix ist.....

Ist das bei allen Compilern so ? bzw. in C89 C99 oder ähnlichem so dokumentiert ?

Danke Euch,
mfg. Siro

[Moebius]

Was soll der Doppelpunkt im Struct den bedeuten? Sollte das nicht eher ein "=" sein?

Ich vermute du hast den Wert somit einfach nicht initialisiert und es kommt somit Unsinn heraus.

Mfg Moebius

[BurningWave]

Der Doppelpunkt (: X) beduetet, dass die Variable eine Größe von X Bits haben soll (Bitfeld).

Wäre es nicht sinnvoller statt int char zu nehmen, wenn du nur ein Bit brauchst? Ich denke, dass der Compiler das einfach "übersieht", bzw. keine Warnung dafür hat. In der Praxis würde ich aber von solch einer Zuweisung abraten

[Moebius]

Der Doppelpunkt (: X) beduetet, dass die Variable eine Größe von X Bits haben soll (Bitfeld).

Ah alles klar. Obwohl ich C ganz gut kenne, habe ich das noch nie gesehen .

Vielleicht kann dein Compiler nur minimal ein int speichern? Hast du schonmal versucht die Größe dein Bitfeldes auszugeben?

printf("%d \n", sizeof(bitField.b1)); 

[BurningWave]

Oder vielleicht wird das einfach wegoptimiert, weil man eigentlich nie so auf den Speicherplatz achten muss und so oder so ein int reserviert werden muss (also 30 Bits übrig bleiben würden). Schalte mal die Optimierungen aus.

[Siro]

zu _R2D2:
Ich habe generell bei meinen Bitdefinitionen einen "int" genommen, da dies dem ANSI-C Standard entspricht.
Wenn ich die Optionen meinens Compilers entsprechund umstelle, kann ich natürlcih auch ein "char" benutzen und in diesem Beispiel 3 Bytes sparen. In meinem Falle werden für die beiden Bits gleich 4 Bytes belegt. 32 Bit Architektur für den LPC1768. Ist hier aber egal, es geht mir nur um das Prinzip. Ich finde es sehr Schade, daß der Compiler keine Warnung auslöst, wenn ich einem einzelnen Bit eine 2, oder einer 3-Bit Definition Werte größer als 7 zuweise. Verblüffend ist, daß der Compiler aber die erforderlichen Bits trotzdem richtig ausmarkiert, er überschreibt also keine "falschen" Bits, innerhalb der Struktur. Immerhin werden das auch gleich 6 Assemblerzeilen für "bits.a = 1;"


------------------------------
für Moebius:

Du kannst ein Byte z.B. wie folgt definieren:

struct
{
char a : 1; /* a hat 1 Bit */
char b : 4; /* b hat 4 Bits */
char c : 2; /* c hat 2 Bits */
char d : 1; /* d hat 1 Bit */
} bits;

nun kannst du vom Programm aus folgendes tun:

bits.a = 1;
bits.b = 0x0F;
bits.c = 3;
bits.d = 0;

Hier hast Du im Prinzip der Variablen "bits" den Wert 127 dezimal zugewiesen.

was leider nicht so ohne weiteres geht, ist der direkte Zugriff auf das gesamte Byte:
bits = 127;

hier könnte man sich mit folgender "unleserlichen" Variante helfen.
*(char*)(&bits) = 127;

oder gibt es vielleicht doch noch eine andere Möglichkeit ????
Ich bin ja auch noch ein "Frischling" was "C" angeht.

Version 2 könnte vielleicht so aussehen:

union
{
  struct 
  {
    char a : 1;    /* a hat 1 Bit */
    char b : 4;    /* b hat 4 Bits */
    char c : 2;    /* c hat 2 Bits */
    char d : 1;    /* d hat 1 Bits */
  } bits;
  char value;
} bitstruct;

int main(void)
{ 
  bitstruct.bits.a = 1;
  bitstruct.bits.b = 0x0F;
  bitstruct.bits.c = 3;
  bitstruct.bits.d = 0;

  bitstruct.value = 127;    /* auf alle Bits gleichzeitig zugreifen */
}

Siro