Por que atribuir um valor a um campo de bit não está retornando o mesmo valor?

Eu vi o código abaixo nesta postagem do 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");
}

Em C e C ++, a saída do código é inesperada ,

Está desabilitado !!

Embora a explicação relacionada ao "bit de sinal" seja dada nessa postagem, não consigo entender como é possível que definamos algo e então isso não reflita como está.

Alguém pode dar uma explicação mais elaborada?

Nota : Ambas as tagsc E c ++são necessários, porque seus padrões diferem ligeiramente para descrever os campos de bits. Veja as respostas para especificações C e especificações C ++ .

Os campos de bits são incrivelmente mal definidos pelo padrão. Dado este código struct mystruct {int enabled:1;};, então não sabemos:

• Quanto espaço isso ocupa - se há bits / bytes de preenchimento e onde eles estão localizados na memória.
• Onde o bit está localizado na memória. Não definido e também depende de endianess.
• Se um campo de int:nbits deve ser considerado com ou sem sinal.

Em relação à última parte, C17 6.7.2.1/10 diz:

Um campo de bits é interpretado como tendo um tipo inteiro assinado ou não assinado, consistindo no número especificado de bits ¹²⁵⁾

Nota não normativa explicando o acima:

¹²⁵⁾ Conforme especificado em 6.7.2 acima, se o especificador de tipo real usado é intou um nome de typedef definido como int, então ele é definido pela implementação se o campo de bits é assinado ou não.

No caso de o campo de bits ser considerado como signed int bits e você fazer um bit de tamanho 1, então não há espaço para dados, apenas para o bit de sinal. Esta é a razão pela qual seu programa pode dar resultados estranhos em alguns compiladores.

Boa prática:

• Nunca use campos de bits para nenhum propósito.
• Evite usar inttipo assinado para qualquer forma de manipulação de bits.

Não consigo entender como é possível que definimos algo e então não apareça como está.

Você está perguntando por que ele compila vs. apresenta um erro?

Sim, o ideal é que ele forneça um erro. E faz, se você usar os avisos do seu compilador. No GCC, com -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;
           ^

O motivo pelo qual isso foi deixado para ser definido pela implementação versus um erro pode ter mais a ver com usos históricos, onde exigir um elenco significaria quebrar o código antigo. Os autores da norma podem acreditar que os avisos foram suficientes para compensar os interessados.

Para acrescentar um pouco de prescritivismo, vou ecoar a declaração de @Lundin: "Nunca use campos de bits para nenhum propósito." Se você tiver bons motivos para ser baixo e específico sobre os detalhes do layout de sua memória, que o levariam a pensar que você precisava de bitfields em primeiro lugar, os outros requisitos associados que você quase certamente terá irão se chocar contra sua subespecificação.

(TL; DR - Se você é sofisticado o suficiente para "precisar" legitimamente de campos de bits, eles não estão bem definidos para atendê-lo.)

Este é o comportamento definido pela implementação. Estou fazendo a suposição de que as máquinas em que você está executando isso usam intinteiros com sinal de dois cumprimentos e tratam neste caso como um inteiro com sinal para explicar por que você não insere a parte if true da instrução if.

struct mystruct { int enabled:1; };

declara enablecomo um campo de 1 bit. Como está assinado, os valores válidos são -1e 0. Definindo o campo para 1transbordar aquele bit voltando para-1 (este é um comportamento indefinido)

Essencialmente, ao lidar com um campo de bits com sinal, o valor máximo é o 2^(bits - 1) - 1que é 0neste caso.

Você pode pensar nisso como no sistema de complemento de 2, o bit mais à esquerda é o bit do sinal. Qualquer número inteiro com sinal com o conjunto de bits mais à esquerda é, portanto, um valor negativo.

Se você tiver um inteiro assinado de 1 bit, ele terá apenas o bit de sinal. Então, atribuindo1 a esse bit único pode definir apenas o bit de sinal. Portanto, ao lê-lo novamente, o valor é interpretado como negativo e, portanto, -1.

Os valores que um inteiro com sinal de 1 bit pode conter são -2^(n-1)= -2^(1-1)= -2^0= -1e2^n-1= 2^1-1=0

De acordo com o padrão C ++ n4713 , um trecho de código muito semelhante é fornecido. O tipo usado é BOOL(personalizado), mas pode se aplicar a qualquer tipo.

12.2.4

⁴ Se o valor true ou false for armazenado em um campo de bitsboolde qualquer tamanho (incluindo um campo de bits de um bit), oboolvalororiginale o valor do campo de bits devem ser comparados. Se o valor de um enumerador for armazenado em um campo de bits do mesmo tipo de enumeração e o número de bits no campo de bits for grande o suficiente para conter todos os valores desse tipo de enumeração (10.2), o valor do enumerador original e o o valor do campo de bits deve ser igual . [Exemplo:

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

- exemplo final]

À primeira vista, a parte em negrito parece aberta para interpretação. No entanto, a intenção correta torna-se clara quando o enum BOOLé derivado do 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");
}

Com o código acima, ele dá um aviso sem -Wall -pedantic:

aviso: 'mystruct :: enabled' é muito pequeno para conter todos os valores de 'enum BOOL' struct mystruct { BOOL enabled:1; };

O resultado é:

Está desabilitado !! (ao usar enum BOOL : int)

Se enum BOOL : intfor simplificado enum BOOL, a saída será como a passagem padrão acima especifica:

Está habilitado (ao usar enum BOOL)

Portanto, pode-se concluir, também como poucas outras respostas, que o inttipo não é grande o suficiente para armazenar o valor "1" em um único campo de bits.

Não há nada de errado com sua compreensão de bitfields que eu possa ver. O que vejo é que você redefiniu mystruct primeiro como struct mystruct {int enabled: 1; } e então como struct mystruct s; . O que você deveria ter codificado 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");
}