Почему присвоение значения битовому полю не возвращает то же значение?

В этом сообщении на 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");
}

Как в C, так и в C ++ вывод кода является неожиданным ,

Выключен !!

Хотя объяснение, связанное с «битом знака», дается в этом посте, я не могу понять, как это возможно, что мы что-то устанавливаем, а затем это не отражает как есть.

Может кто-нибудь дать более подробное объяснение?

Примечание : оба тегаc & c ++являются обязательными, потому что их стандарты немного отличаются для описания битовых полей. См ответы спецификации C и спецификации C ++ .

Битовые поля невероятно плохо определены стандартом. Учитывая этот код struct mystruct {int enabled:1;};, мы не знаем:

• Сколько места это занимает - есть ли биты / байты заполнения и где они расположены в памяти.
• Где находится бит в памяти. Не определено и также зависит от порядка байтов.
• int:nСледует ли рассматривать битовое поле как подписанное или беззнаковое.

Что касается последней части, C17 6.7.2.1/10 говорит:

Битовое поле интерпретируется как имеющее знаковый или беззнаковый целочисленный тип, состоящий из указанного количества битов ¹²⁵⁾

Ненормативное примечание, поясняющее вышеуказанное:

¹²⁵⁾ Как указано в п. 6.7.2 выше, если фактический используемый спецификатор типа intили typedef-name определен как int, то определяется реализацией, является ли битовое поле подписанным или беззнаковым.

В случае, если битовое поле должно рассматриваться как signed intи вы делаете немного размера 1, тогда нет места для данных, только для бит знака. Это причина, по которой ваша программа может давать странные результаты на некоторых компиляторах.

Хорошая практика:

• Никогда не используйте битовые поля для каких-либо целей.
• Избегайте использования подписанного intтипа для любых форм битовых манипуляций.

Я не могу понять, как это возможно, что мы что-то устанавливаем, а потом это не отображается как есть.

Вы спрашиваете, почему он компилируется vs. дает вам ошибку?

Да, в идеале он должен выдать ошибку. И это так, если вы используете предупреждения вашего компилятора. В GCC с -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;
           ^

Обоснование того, почему это оставлено на усмотрение реализации, а не ошибка, может иметь больше отношения к историческому использованию, где требование приведения означало бы нарушение старого кода. Авторы стандарта могут полагать, что предупреждений было достаточно, чтобы восполнить пробел для заинтересованных сторон.

Чтобы добавить некоторого прескриптивизма, я повторю утверждение @Lundin: «Никогда не используйте битовые поля для каких-либо целей». Если у вас есть веские причины, чтобы получить низкоуровневую и конкретную информацию о деталях макета памяти, которые заставят вас думать, что вам нужны битовые поля в первую очередь, другие связанные требования, которые у вас почти наверняка будут, столкнутся с их недостаточной спецификацией.

(TL; DR - Если вы достаточно опытны, чтобы законно "нуждаться" в битовых полях, они недостаточно четко определены, чтобы служить вам.)

Это поведение, определяемое реализацией. Я делаю предположение, что машины, на которых вы запускаете это, используют целые числа со знаком, дополняющие два, и обрабатывают intв этом случае целое число со знаком, чтобы объяснить, почему вы не вводите if true часть оператора if.

struct mystruct { int enabled:1; };

объявляется enableкак 1-битовое битовое поле. Поскольку он подписан, допустимыми значениями являются -1и 0. Настройка поля на 1переполнение этого бита, возвращающегося к -1(это неопределенное поведение)

По существу , когда имеет дело с подписанным битовым полем максимального значение , 2^(bits - 1) - 1которое является 0в данном случае.

Вы можете думать об этом как о том, что в системе дополнения до 2 крайний левый бит является битом знака. Таким образом, любое целое число со знаком с крайним левым битом является отрицательным значением.

Если у вас есть 1-битное целое число со знаком, оно имеет только знаковый бит. Таким образом, присвоение 1этому единственному биту может установить только знаковый бит. Таким образом, при чтении его значение интерпретируется как отрицательное, поэтому оно равно -1.

Значения 1 бит знаковое целое способна хранить -2^(n-1)= -2^(1-1)= -2^0= -1и2^n-1= 2^1-1=0

В соответствии со стандартом C ++ n4713 предоставляется очень похожий фрагмент кода. Используемый тип - BOOL(пользовательский), но он может применяться к любому типу.

12.2.4

⁴ Если значение «истина» или «ложь» сохраняется в битовом полеboolлюбого размера (включая однобитовое битовое поле), исходноеboolзначение и значение битового поля должны сравниваться равными. Если значение перечислителя хранится в битовом поле того же типа перечисления и количество битов в битовом поле достаточно велико, чтобы содержать все значения этого типа перечисления (10.2), исходное значение перечислителя и значение битового поля должно сравниваться равным . [ Пример:

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

- конец примера]

На первый взгляд жирная часть кажется открытой для интерпретации. Однако правильное намерение становится ясным, когда enum BOOLобъект является производным от 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");
}

С приведенным выше кодом он дает предупреждение без -Wall -pedantic:

предупреждение: mystruct :: enabled слишком мал, чтобы содержать все значения enum BOOL struct mystruct { BOOL enabled:1; };

Результат:

Выключен !! (при использовании enum BOOL : int)

Если enum BOOL : intсделано просто enum BOOL, то вывод будет таким, как указано в приведенном выше стандартном пассаже:

Включено (при использовании enum BOOL)

Следовательно, можно сделать вывод, как и несколько других ответов, что этот intтип недостаточно велик для хранения значения «1» только в одном битовом поле.

Нет ничего плохого в вашем понимании битовых полей, которые я вижу. Я вижу, что вы сначала переопределили mystruct как struct mystruct {int enabled: 1; } а затем как struct mystruct s; . Вы должны были закодировать:

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