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

[Moebius]

Meine printf Anweisung war nicht ganz legitim in ANSI-C. (http://stackoverflow.com/questions/81294/sizeofbitfield-type-legal-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)

[Siro]

Hallo Moebius,
danke, daß Du es mal ausprobiert hast mit dem GCC. Bei meinem IAR-Compiler gibt es aber leider kein Warning. Ich weis auch nicht annähernd, wo man bei der IAR Embedded Workbench einen Warninglevel einstellen könnte. In den Hilfen von IAR habe ich auch nichts gefunden. Sehr merkwürdig.

Ich habe mal eben diverse Kuriositäten mit dem NXP LpcXPresso ausprobiert, dieser basiert wohl auf dem GNU Compiler, Oberfläche Eclipse.
Und siehe da, dort werden all meine Probleme einwandfrei erkannt und angemeckert. Zudem habe ich dort schnell gefunden, wo man den Warning-Level einstellen kann.
Wieso geht das nicht mit dem IAR-Compiler ?

Kann mir irgend jemand sagen, wie oder wo man den Warning Level bei der IAR Embedded Workbench einstellen kann ????
Oder geht das evtl. nicht, weil ich keine Vollversion habe nur das Kickstart ?

Danke Euch Siro