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

[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

[Moebius]

Meine printf Anweisung war nicht ganz legitim in ANSI-C. (http://stackoverflow.com/questions/8...egal-in-ansi-c)

Ich habe mal das Programm selber geschrieben und mit dem GCC compiliert. Bei mir funktioniert alles wie es soll:

        struct
    {
        int a : 2;
    } TestStruct;
    TestStruct.a = 3; 

De Code wird ohne Fehler compiliert. Dieser Code:

        struct
    {
        int a : 2;
    } TestStruct;
    TestStruct.a = 4; 

liefert die Compiler-Warnung:

main.c:21: warning: overflow in implicit constant conversion

Mfg Moebius

[BurningWave]

Also liegt es doch am Compiler.

*(char*)(&bits) = 127;

Casten ist die einzige Möglichkeit, ein Bitfeld zu konvertieren, sonst geht es über Unions, wie du es schon gemacht hast. Ich bin mir nicht sicher, ob es auch so geht: (char)(bits)