标签: bit-fields

假设我需要在结构中存储8个bool,但是我想一起使用它们只有1个字节,那么我可以这样做:

struct myStruct {
    bool b1:1;
    bool b2:1;
    bool b3:1;
    bool b4:1;
    bool b5:1;
    bool b6:1;
    bool b7:1;
    bool b8:1;
};

有了这个我可以做的事情

myStruct asdf;
asdf.b3=true;
asdf.b4=false;
if(asdf.b1)
    ...

到目前为止这是正确的吗？(我实际上并不知道,我之前从未使用过bitfields)

好的 - 但是也可以创建一个8个bool的静态数组,这样它们只能使用8位但是我仍然可以通过索引来加入它们吗？

就像是

struct myStruct {
public:
    bool b[8]:8;
};

也许？(有了这个,我得到一个错误C2033)

谢谢您的帮助!

struct A
{
 int a:2;
 int b:3;
 int c:3;
};

int main()
{
 struct A p = {2,6,1};
 printf("\n%d\n%d\n%d\n",p.a,p.b,p.c);
 return 0;
}    

输出为:-2,-2,1

在C complier和C++编译器中输出上述代码的内容是什么？为什么？

在C中是否可以将以下结构的大小设为2？

#include <stdio.h>

struct union_struct {
    char foo;
    char bar : 2;
    union {
        char foobar1 : 6;
        char foobar2 : 6;
    };
};

int main(void)
{
    printf("size of union struct: %d\n", sizeof(struct union_struct));
    return 0;
}

输出,用gcc编译:

size of union struct: 3

这是如何运作的？

struct {
    int a : 21;
    int b : 11;
};

a和b是两个单独的int变量还是使用不同位域的相同变量？

我正在尝试执行以下操作,但是NSValue创建方法会返回nil.结构中的C位域是否不受支持？

struct MyThingType {
    BOOL isActive:1;
    uint count:7;
} myThing = {
    .isActive = YES,
    .count = 3,
};

NSValue *value = [NSValue valueWithBytes:&myThing objCType:@encode(struct MyThingType)];
// value is nil here

我创建了一个带有相应Union的ctype位域结构,通过单个位域和整数值来访问它.我能够使用包含字段名称的变量设置单个字段,但现在我想知道特定字段属于哪个字节.这是我的代码示例:

import ctypes

c_short = ctypes.c_uint16

class Flags_bits(ctypes.LittleEndianStructure):
    _fields_ = [
        ("bitField1", c_short, 1),
        ("bitField2", c_short, 4),
        ("bitField3", c_short, 6),
        ("bitField4", c_short, 1),
        ("bitField5", c_short, 2),
        ("bitField6", c_short, 2),

        ("bitField7", c_short, 6),
        ("bitField8", c_short, 4),
        ("bitField9", c_short, 4),
        ("bitField10", c_short, 1),
        ("bitField11", c_short, 1)]

class Flags(ctypes.Union):
    _fields_ = [("b", Flags_bits),
                ("asInt", c_short*6)]

def setFlag (flagName, value):
    flags = Flags()
    setattr(flags.b, flagName, value)        
    print getattr(flags.b, flagName)

现在我想知道的是我的标志属于哪个整数(即哪个flags.asInt [i]),我正在寻找一种"get_location"属性来获取结构中的标志位置并从中检索'i'整数的索引,但我找不到任何东西有没有简单的方法呢？

每个回复都要提前感谢!

我是计算机科学专业的学生。

现在，我正在用C进行计算机架构项目，该项目可模拟处理器。

有很多类型的指令，例如

 31     27 26     22 21     17 16                              0
 ---------------------------------------------------------------
|    op   |    ra   |    rb   |             imm17               |
 ---------------------------------------------------------------

 31     27 26     22 21     17 16                7 6 5 4       0
 ---------------------------------------------------------------
|    op   |    ra   |    rb   |       imm10       | m |  shamt  |
 ---------------------------------------------------------------

 31     27 26     22 21                                        0
 ---------------------------------------------------------------
|    op   |    ra   |                  imm22                    |
 ---------------------------------------------------------------

因此，我想制作一个C结构，其中包含与每个元素（例如op，ra等）相对应的位域。

起初，我认为我可以使用联合和嵌套结构。

例如，我编写了如下代码：

struct instr_t {
    union {
        uint32_t imm22 : 22;

        struct {
            union { …

我正在学习C.在C Primer Plus中,我看到了一个字段示例如下:

struct box_props {
    bool opaque               : 1;
    unsigned int fill_color   : 3;
    unsigned int              : 4;
    bool show_border          : 1;
    unsigned int border_color : 3;
    unsigned int border_style : 2;
    unsigned int              : 2;
};

我知道中间的4位未命名位字段用于让以下位从一个新字节开始.但是,我不明白为什么在结构的末尾有另一个未命名的位字段.它的目的是什么？有必要吗？

我有一个使用16位浮点数的框架，我想分离其组件，然后用于32位浮点数。在我的第一种方法中，我使用了移位和类似的方法，尽管这种方法有效，但是阅读却非常混乱。

然后，我想改用自定义位大小的结构，并使用联合写入该结构。

重现该问题的代码：

#include <iostream>
#include <stdint.h>

union float16_and_int16
{
    struct
    {
        uint16_t    Mantissa : 10;
        uint16_t    Exponent : 5;
        uint16_t    Sign : 1;
    } Components;

    uint16_t bitMask;
};

int main()
{
    uint16_t input = 0x153F;

    float16_and_int16 result;
    result.bitMask = input;

    printf("Mantissa: %#010x\n", result.Components.Mantissa);
    printf("Exponent: %#010x\n", result.Components.Exponent);
    printf("Sign:     %#010x\n", result.Components.Sign);
    return 0;
}

在示例中，我希望尾数为0x00000054，指数为0x0000001F，符号为0x00000001

相反，我得到了尾数：0x0000013f，指数：0x00000005，符号：0x00000000

这意味着从我的位掩码开始，首先取了符号（第一个位），然后是5位到指数，然后是10位到尾数，因此顺序与我想要的顺序相反。为什么会这样呢？

我以前在 C 方面有过一些经验，但是我以前从未见过位域功能。我知道可以使用位掩码来隔离数据结构中的某些位，但是为什么还要使用位域呢？

例如，假设我们要隔离的位是前 3 个最低有效位。然后我们可以写：

/* our bitmasks */
#define FIELD_A (1 << 0)
#define FIELD_B (1 << 1)
#define FIELD_C (1 << 2)

int main(void) 
{ 
    /* the data structure that contains our three fields */
    uint8_t flags;

    /* accessing field A (as a boolean) */
    int bool_a = !!(flags & FIELD_A);

    /* accessing field B (as a boolean) */
    int bool_b = !!(flags & FIELD_B);

    /* accessing field C (as a boolean) */
    int bool_c = !!(flags …