Warum gibt das Zuweisen eines Werts zu einem Bitfeld nicht denselben Wert zurück?

Ich habe den folgenden Code in diesem Quora-Beitrag gesehen :

#include <stdio.h>

struct mystruct { int enabled:1; };
int main()
{
  struct mystruct s;
  s.enabled = 1;
  if(s.enabled == 1)
    printf("Is enabled\n"); // --> we think this to be printed
  else
    printf("Is disabled !!\n");
}

In C & C ++ ist die Ausgabe des Codes unerwartet .

Ist behindert !!

Obwohl die Erklärung zum "Vorzeichenbit" in diesem Beitrag enthalten ist, kann ich nicht verstehen, wie es möglich ist, dass wir etwas festlegen und es dann nicht so widerspiegelt, wie es ist.

Kann jemand eine ausführlichere Erklärung geben?

Hinweis : Beide Tagsc & c ++sind erforderlich, da sich ihre Standards zur Beschreibung der Bitfelder geringfügig unterscheiden. Siehe Antworten zur C-Spezifikation und C ++ - Spezifikation .

Bitfelder sind vom Standard unglaublich schlecht definiert. Angesichts dieses Codes wissen struct mystruct {int enabled:1;};wir nicht :

• Wie viel Platz dies einnimmt - wenn Füllbits / Bytes vorhanden sind und wo sie sich im Speicher befinden.
• Wo sich das Bit im Speicher befindet. Nicht definiert und hängt auch von der Endianess ab.
• int:nGibt an, ob ein Bitfeld als signiert oder nicht signiert anzusehen ist.

In Bezug auf den letzten Teil heißt es in C17 6.7.2.1/10:

Ein Bitfeld wird so interpretiert, dass es einen vorzeichenbehafteten oder vorzeichenlosen Ganzzahltyp hat, der aus der angegebenen Anzahl von Bits besteht. ¹²⁵⁾

Nicht normativer Hinweis zur Erläuterung des oben Gesagten:

¹²⁵⁾ Wie in 6.7.2 oben angegeben, ist, wenn der tatsächlich verwendete Typbezeichner intoder ein typedef-Name definiert intist, implementierungsdefiniert, ob das Bitfeld signiert oder nicht signiert ist.

Wenn das Bitfeld als betrachtet werden soll signed intund Sie ein bisschen Größe machen 1, gibt es keinen Platz für Daten, nur für das Vorzeichenbit. Dies ist der Grund, warum Ihr Programm bei einigen Compilern möglicherweise seltsame Ergebnisse liefert.

Gute Übung:

• Verwenden Sie niemals Bitfelder für irgendeinen Zweck.
• Vermeiden Sie die Verwendung eines vorzeichenbehafteten intTyps für jede Form der Bitmanipulation.

Ich kann nicht verstehen, wie es möglich ist, dass wir etwas einstellen und es dann nicht so angezeigt wird, wie es ist.

Fragen Sie sich, warum es kompiliert oder Ihnen einen Fehler gibt?

Ja, es sollte idealerweise einen Fehler geben. Und das tut es, wenn Sie die Warnungen Ihres Compilers verwenden. In GCC mit -Werror -Wall -pedantic:

main.cpp: In function 'int main()':
main.cpp:7:15: error: overflow in conversion from 'int' to 'signed char:1' 
changes value from '1' to '-1' [-Werror=overflow]
   s.enabled = 1;
           ^

Die Gründe, warum dies der Implementierung überlassen bleibt, im Vergleich zu einem Fehler, haben möglicherweise mehr mit historischen Verwendungen zu tun, bei denen das Erfordernis einer Besetzung bedeuten würde, alten Code zu beschädigen. Die Autoren des Standards glauben möglicherweise, dass Warnungen ausreichten, um die Lücke für die Betroffenen zu schließen.

Um ein wenig Verschreibungspflicht einzubringen, werde ich @ Lundins Aussage wiederholen: "Verwenden Sie niemals Bitfelder für irgendeinen Zweck." Wenn Sie die guten Gründe haben, sich über Ihre Speicherlayoutdetails zu informieren, die Sie zu der Annahme veranlassen würden, dass Sie überhaupt Bitfelder benötigen, werden die anderen damit verbundenen Anforderungen, die Sie mit ziemlicher Sicherheit haben, auf deren Unterspezifikation stoßen.

(TL; DR - Wenn Sie hoch genug sind, um Bitfelder zu "benötigen", sind sie nicht gut genug definiert, um Ihnen zu dienen.)

Dies ist ein implementierungsdefiniertes Verhalten. Ich gehe davon aus, dass die Maschinen, auf denen Sie dies ausführen, vorzeichenbehaftete Ganzzahlen mit zwei Komplimenten verwenden und intin diesem Fall als vorzeichenbehaftete Ganzzahl behandeln, um zu erklären, warum Sie keinen if true-Teil der if-Anweisung eingeben.

struct mystruct { int enabled:1; };

deklariert enableals 1-Bit-Bitfeld. Da es signiert ist, sind die gültigen Werte -1und 0. Setzen Sie das Feld so, 1dass das Bit, auf das zurückgegangen wird, überläuft -1(dies ist ein undefiniertes Verhalten).

Im Wesentlichen ist beim Umgang mit einem vorzeichenbehafteten Bitfeld der Maximalwert 2^(bits - 1) - 1der 0in diesem Fall.

Man könnte sich vorstellen, dass im Komplementsystem der 2 das Bit ganz links das Vorzeichenbit ist. Jede vorzeichenbehaftete Ganzzahl mit dem am weitesten links stehenden Bit ist daher ein negativer Wert.

Wenn Sie eine 1-Bit-Ganzzahl mit Vorzeichen haben, hat sie nur das Vorzeichenbit. Die Zuweisung 1zu diesem einzelnen Bit kann also nur das Vorzeichenbit setzen. Beim Zurücklesen wird der Wert als negativ interpretiert, ebenso wie -1.

Die Werte, die eine 1-Bit-Ganzzahl mit Vorzeichen enthalten kann, sind -2^(n-1)= -2^(1-1)= -2^0= -1und2^n-1= 2^1-1=0

Gemäß dem C ++ - Standard n4713 wird ein sehr ähnliches Code-Snippet bereitgestellt. Der verwendete Typ ist BOOL(benutzerdefiniert), kann jedoch für jeden Typ gelten.

12.2.4

⁴ Wenn der Wert true oder false in einem Bitfeldbooleines beliebigenTyps(einschließlich eines Ein-Bit-Bitfelds)gespeichert wird, müssen der ursprünglicheboolWert und der Wert des Bitfelds gleich sein. Wenn der Wert eines Enumerators in einem Bitfeld desselben Aufzählungstyps gespeichert ist und die Anzahl der Bits im Bitfeld groß genug ist, um alle Werte dieses Aufzählungstyps (10.2) aufzunehmen, werden der ursprüngliche Aufzählerwert und der Der Wert des Bitfeldes soll gleich sein . [Beispiel:

enum BOOL { FALSE=0, TRUE=1 };
struct A {
  BOOL b:1;
};
A a;
void f() {
  a.b = TRUE;
  if (a.b == TRUE)    // yields true
    { /* ... */ }
}

- Beispiel beenden]

Auf den ersten Blick erscheint der fette Teil offen für Interpretationen. Die richtige Absicht wird jedoch klar, wenn die enum BOOLvon der abgeleitet wird int.

enum BOOL : int { FALSE=0, TRUE=1 }; // ***this line
struct mystruct { BOOL enabled:1; };
int main()
{
  struct mystruct s;
  s.enabled = TRUE;
  if(s.enabled == TRUE)
    printf("Is enabled\n"); // --> we think this to be printed
  else
    printf("Is disabled !!\n");
}

Mit dem obigen Code wird eine Warnung ausgegeben ohne -Wall -pedantic:

Warnung: 'mystruct :: enabled' ist zu klein, um alle Werte von 'enum BOOL' zu speichern. struct mystruct { BOOL enabled:1; };

Die Ausgabe ist:

Ist behindert !! (bei Verwendung enum BOOL : int)

Wenn dies vereinfacht enum BOOL : intwird, erfolgt enum BOOLdie Ausgabe wie in der obigen Standard-Passage angegeben:

Ist aktiviert (bei Verwendung enum BOOL)

Daher kann, wie auch nur wenige andere Antworten, gefolgert werden, dass der intTyp nicht groß genug ist, um den Wert "1" in nur einem einzelnen Bitbitfeld zu speichern.

Es ist nichts Falsches an Ihrem Verständnis von Bitfeldern, das ich sehen kann. Was ich sehe ist, dass Sie Mystruct zuerst als Struct Mystruct neu definiert haben {int enabled: 1; } und dann als struct mystruct s; . Was Sie hätten codieren sollen, war:

#include <stdio.h>

struct mystruct { int enabled:1; };
int main()
{
    mystruct s; <-- Get rid of "struct" type declaration
    s.enabled = 1;
    if(s.enabled == 1)
        printf("Is enabled\n"); // --> we think this to be printed
    else
        printf("Is disabled !!\n");
}