Perché l'assegnazione di un valore a un campo di bit non restituisce lo stesso valore?

Ho visto il codice seguente in questo post di Quora :

#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");
}

Sia in C che in C ++, l'output del codice è inaspettato ,

È disabilitato !!

Sebbene la spiegazione relativa al "bit di segno" sia fornita in quel post, non sono in grado di capire come sia possibile che impostiamo qualcosa e poi non rifletta così com'è.

Qualcuno può dare una spiegazione più elaborata?

Nota : entrambi i tagc & c ++sono obbligatori, perché i loro standard differiscono leggermente per la descrizione dei campi di bit. Vedi le risposte per la specifica C e la specifica C ++ .

I campi di bit sono incredibilmente poco definiti dallo standard. Dato questo codice struct mystruct {int enabled:1;};, allora non sappiamo:

• Quanto spazio occupa questo - se ci sono bit / byte di riempimento e dove si trovano in memoria.
• Dove si trova il bit in memoria. Non definito e dipende anche dall'endianess.
• Indica se un int:ncampo di bit deve essere considerato come firmato o non firmato.

Per quanto riguarda l'ultima parte, C17 6.7.2.1/10 dice:

Un campo di bit viene interpretato come avente un tipo intero con segno o senza segno costituito dal numero di bit specificato ¹²⁵⁾

Nota non normativa che spiega quanto sopra:

¹²⁵⁾ Come specificato in 6.7.2 sopra, se l'effettivo identificatore di tipo utilizzato è into un nome typedef definito come int, allora è definito dall'implementazione se il campo bit è con segno o senza segno.

Nel caso in cui il campo di signed intbit debba essere considerato come e si crea un po 'di dimensione 1, non c'è spazio per i dati, solo per il bit di segno. Questo è il motivo per cui il tuo programma potrebbe dare risultati strani su alcuni compilatori.

Buona pratica:

• Non utilizzare mai campi di bit per nessuno scopo.
• Evita di utilizzare il inttipo con segno per qualsiasi forma di manipolazione dei bit.

Non riesco a capire come sia possibile che impostiamo qualcosa e poi non si presenti così com'è.

Stai chiedendo perché si compila e ti dà un errore?

Sì, idealmente dovrebbe darti un errore. E lo fa, se usi gli avvisi del tuo compilatore. In GCC, con -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;
           ^

Il motivo per cui questo viene lasciato alla definizione dell'implementazione rispetto a un errore potrebbe avere più a che fare con gli usi storici, dove richiedere un cast significherebbe rompere il vecchio codice. Gli autori dello standard potrebbero ritenere che gli avvertimenti fossero sufficienti per aumentare la tensione per gli interessati.

Per aggiungere un po 'di prescrittivismo, farò eco all'affermazione di @ Lundin: "Non usare mai campi di bit per nessuno scopo". Se hai il tipo di buone ragioni per ottenere un livello basso e specifico sui dettagli del layout della memoria che ti farebbero pensare che avevi bisogno di bitfield in primo luogo, gli altri requisiti associati che quasi certamente hai si scontreranno con la loro sottospecificazione.

(TL; DR - Se sei abbastanza sofisticato da "necessitare" legittimamente di campi di bit, non sono sufficientemente definiti per servirti.)

Questo è il comportamento definito dall'implementazione. Sto assumendo che le macchine su cui stai eseguendo questo utilizzo utilizzino interi con segno di complimento a due e trattino intin questo caso come un intero con segno per spiegare perché non inserisci if true parte dell'istruzione if.

struct mystruct { int enabled:1; };

dichiara enablecome un campo di bit a 1 bit. Poiché è firmato, i valori validi sono -1e 0. L'impostazione del campo su 1trabocca quel bit che torna a -1(questo è un comportamento indefinito)

Essenzialmente quando si ha a che fare con un campo di bit con segno il valore massimo è 2^(bits - 1) - 1che è 0in questo caso.

Potresti pensare che nel sistema del complemento a 2, il bit più a sinistra è il bit del segno. Qualsiasi numero intero con segno con il bit più a sinistra impostato è quindi un valore negativo.

Se hai un intero con segno a 1 bit, ha solo il bit di segno. Quindi l'assegnazione 1a quel singolo bit può impostare solo il bit di segno. Quindi, quando lo rileggi, il valore viene interpretato come negativo e così è -1.

I valori che un intero con segno a 1 bit può contenere è -2^(n-1)= -2^(1-1)= -2^0= -1e2^n-1= 2^1-1=0

Come per lo standard C ++ n4713 , viene fornito uno snippet di codice molto simile. Il tipo utilizzato è BOOL(personalizzato), ma può essere applicato a qualsiasi tipo.

12.2.4

⁴ Se il valore vero o falso è memorizzato in un campo di bitbooldi qualsiasi dimensione (incluso un campo di bit di un bit), ilboolvaloreoriginalee il valore del campo di bit devono essere confrontati uguali. Se il valore di un enumeratore è memorizzato in un campo di bit dello stesso tipo di enumerazione e il numero di bit nel campo di bit è abbastanza grande da contenere tutti i valori di quel tipo di enumerazione (10.2), il valore dell'enumeratore originale e il il valore del campo di bit deve confrontare uguale . [ Esempio:

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

- esempio finale]

A prima vista, la parte in grassetto sembra aperta all'interpretazione. Tuttavia, l'intento corretto diventa chiaro quando enum BOOLviene derivato da 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");
}

Con il codice sopra dà un avviso senza -Wall -pedantic:

avviso: "mystruct :: enabled" è troppo piccolo per contenere tutti i valori di "enum BOOL" struct mystruct { BOOL enabled:1; };

L'output è:

È disabilitato !! (quando si usa enum BOOL : int)

Se enum BOOL : intè reso semplice enum BOOL, l'output è come il passaggio standard sopra specificato:

È abilitato (durante l'utilizzo enum BOOL)

Quindi, si può concludere, anche come poche altre risposte hanno fatto, che il inttipo non è abbastanza grande da memorizzare il valore "1" in un solo campo di bit.

Non c'è niente di sbagliato nella tua comprensione dei campi di bit che posso vedere. Quello che vedo è che hai ridefinito prima mystruct come struct mystruct {int enabled: 1; } e poi come struct mystruct s; . Quello che avresti dovuto codificare era:

#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");
}