Чому присвоєння значення бітовому полю не повертає однакове значення?

Я бачив наведений нижче код у цій публікації 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, визначене як int, тоді визначається реалізацією, підписано чи не підписано поле біта.

Якщо бітове поле слід розглядати як signed intі ви зробите трохи розміру 1, тоді місця для даних немає, лише для знакового біта. Ось чому ваша програма може дати дивні результати на деяких компіляторах.

Гарна практика:

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

Я не можу зрозуміти, як можливо, що ми щось встановлюємо, а потім воно не відображається як є.

Ви запитуєте, чому компіляція проти видає помилку?

Так, в ідеалі це повинно привести до помилки. І це робиться, якщо ви використовуєте попередження компілятора. У країнах 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;
           ^

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

Щоб підкинути деякий рецептивізм, я повторю вислів @ Лундіна: "Ніколи не використовуйте бітові поля для будь-яких цілей". Якщо у вас є вагомі причини, щоб отримати низький рівень і конкретні деталі розмітки вашої пам'яті, які б змусили вас думати, що вам потрібні бітові поля, в першу чергу, інші пов'язані з вами вимоги, які ви майже напевно маєте, зіткнуться з їх недостатньою специфікацією.

(TL; DR - Якщо ви достатньо витончені, щоб законно "потребувати" бітові поля, вони недостатньо чітко визначені, щоб обслуговувати вас.)

Це поведінка, визначена реалізацією. Я роблю припущення, що машини, на яких ви використовуєте це, використовують цілі числа із двома компліментами із підписом і розглядають intу цьому випадку ціле число зі знаком, щоб пояснити, чому ви не вводите, якщо істинна частина оператора 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

⁴ Якщо значення true або false зберігається у бітовому полі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");
}