位域-在内存中存储的分析

最新推荐文章于 2022-10-26 01:46:20 发布
最新推荐文章于 2022-10-26 01:46:20 发布
阅读量666 收藏 3
点赞数 1
分类专栏： C语言 文章标签： 位域 大小端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amei113/article/details/84668939
版权
1. 用于分析的代码
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stddef.h>

#pragma pack(8) /* 指定 8 字节对齐 */
/* 测试机器字长: 64bit 
 * 大端测试: T2080
 * 小端测试: Intel i3
 * */

/* 位域字段长度大于 8 字节但非 8 字节整数倍, 且整个结构体占用刚好一个机器字长 */
struct bitField1 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned long a:10;
    unsigned long b:10;
    unsigned long c:20;
    unsigned long d:24;
#else
    unsigned long d:24;
    unsigned long c:20;
    unsigned long b:10;
    unsigned long a:10;
#endif
} bitFieldTest1;

/* 位域字段长度小于 8 字节, 且整个结构体占用刚好一个机器字长 */
struct bitField2 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned long a:2;
    unsigned long b:6;
    unsigned long c:4;
    unsigned long d:52;
#else
    unsigned long d:52;
    unsigned long c:4;
    unsigned long b:6;
    unsigned long a:2;
#endif
} bitFieldTest2;

/* 占用不到一个机器字长 */
struct bitField3 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned long a:2;
    unsigned long b:6;
    unsigned long c:4;
#else
    unsigned long c:4;
    unsigned long b:6;
    unsigned long a:2;
#endif
} bitFieldTest3;

/* 位域字段不到一个机器字长时，中间嵌入其他类型成员 */
struct bitField4 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned long a:2;
    unsigned long b:6;
    unsigned long c:4;
    unsigned int e;
    unsigned long d:52;
#else
    unsigned long d:52;
    unsigned int e;
    unsigned long c:4;
    unsigned long b:6;
    unsigned long a:2;
#endif
} bitFieldTest4;

/* 各种类型的位域融合到一起 */
struct bitField5 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned short a:2;
    unsigned short b:6;
    unsigned int c:4;
    unsigned int e;
    unsigned long d:52;
#else
    unsigned long d:52;
    unsigned int e;
    unsigned int c:4;
    unsigned short b:6;
    unsigned short a:2;
#endif
} bitFieldTest5;

/* 各种类型的位域融合到一起, 且不指定 signed/unsigned */
struct bitField6 {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    short a:2;
    short b:6;
    int c:4;
    int e;
    long d:52;
#else
    long d:52;
    int e;
    int c:4;
    short b:6;
    short a:2;
#endif
} bitFieldTest6;

int binary2decimal(char *str)
{
    int i;
    int ret = 0;
    
    for (i = 0; i < 8; i++) {
        ret += ((1 << (7 - i)) * (str[i] - '0'));
    }

    return ret;
}

char *expand_binary(unsigned long x, int len)
{
    static char str[128];
    int i;

    str[len] = '\0';
    for (i = len - 1; i >= 0; i--) {
        str[len - 1 - i] = 0x30 + !!(x & (1ul << i));
    }

    return str;
}

char *binaryStr(char *p)
{
    static char ret[9];

    memcpy(ret, p, 8);
    ret[8] = '\0';

    return ret;
}

void print_analy1(struct bitField1 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 10));
    printf("%s, ", expand_binary(p->b, 10));
    printf("%s, ", expand_binary(p->c, 20));
    printf("%s\n", expand_binary(p->d, 24));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 24));
    strcat(str, expand_binary(p->c, 20));
    strcat(str, expand_binary(p->b, 10));
    strcat(str, expand_binary(p->a, 10));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->d, 24));
    printf("%s, ", expand_binary(p->c, 20));
    printf("%s, ", expand_binary(p->b, 10));
    printf("%s\n", expand_binary(p->a, 10));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 24));
    strcat(str, expand_binary(p->c, 20));
    strcat(str, expand_binary(p->b, 10));
    strcat(str, expand_binary(p->a, 10));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void print_analy2(struct bitField2 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s\n", expand_binary(p->d, 52));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->a, 2));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void print_analy3(struct bitField3 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s\n", expand_binary(0, 52));
    printf("High->Low:");
    strcpy(str, expand_binary(0, 52));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s\n", expand_binary(0, 52));
    printf("High->Low:");
    strcpy(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    strcat(str, expand_binary(0, 52));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void print_analy4(struct bitField4 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(0, 20)); // 对齐到 32 位即可
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s\n", expand_binary(0, 12));
    printf("High->Low:");
    strcpy(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(0, 20));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s, ", expand_binary(0, 12));
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s\n", expand_binary(0, 20));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    strcat(str, expand_binary(0, 20));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void print_analy5(struct bitField5 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(0, 20));
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s\n", expand_binary(0, 12));
    printf("High->Low:");
    strcpy(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(0, 20));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s, ", expand_binary(0, 12));
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s\n", expand_binary(0, 20));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    strcat(str, expand_binary(0, 20));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void print_analy6(struct bitField6 *p)
{
    char str[512];
    int i;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("Little-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(0, 20));
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s\n", expand_binary(0, 12));
    printf("High->Low:");
    strcpy(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(0, 20));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = strlen(str) - 8; i >= 0; i -= 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#else
    printf("Big-Endian Analysis:\n");
    printf("Expand order:");
    printf("%s, ", expand_binary(p->d, 52));
    printf("%s, ", expand_binary(0, 12));
    printf("%s, ", expand_binary(p->e, 32));
    printf("%s, ", expand_binary(p->c, 4));
    printf("%s, ", expand_binary(p->b, 6));
    printf("%s, ", expand_binary(p->a, 2));
    printf("%s\n", expand_binary(0, 20));
    printf("High->Low:");
    strcpy(str, expand_binary(p->d, 52));
    strcat(str, expand_binary(0, 12));
    strcat(str, expand_binary(p->e, 32));
    strcat(str, expand_binary(p->c, 4));
    strcat(str, expand_binary(p->b, 6));
    strcat(str, expand_binary(p->a, 2));
    strcat(str, expand_binary(0, 20));
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s,", binaryStr(&str[i]));
    }
    printf("\n");
    printf("Byte Order(Low->High):");
    for (i = 0; i < strlen(str); i += 8) {
        printf("%08s(%02x),", binaryStr(&str[i]), binary2decimal(&str[i]));
    }
    printf("\n");
#endif
}

void struc_print(char *p, int len)
{
    int i,j;

    printf("binary output: ");
    for (i = 0; i < len; i++) {
        for (j = 7; j >= 0; j--) 
          printf("%d", !!(*(p + i) & (1 << j)));
        printf("(%02x) ", *(p + i) & 0xff);
    }
    printf("\n");
}

int main(void)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    printf("This Little-Endian Machine!\n");
#endif

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    printf("This Big-Endian Machine!\n");
#endif
    bitFieldTest1.a = 0x55;
    bitFieldTest1.b = 0xaa;
    bitFieldTest1.c = 0x5ff;
    bitFieldTest1.d = 0xff1;

    bitFieldTest2.a = 0x1;
    bitFieldTest2.b = 0x14;
    bitFieldTest2.c = 0x5;
    bitFieldTest2.d = 0xc3f1794a;

    bitFieldTest3.a = 0x1;
    bitFieldTest3.b = 0x14;
    bitFieldTest3.c = 0x5;

    bitFieldTest4.a = 0x1;
    bitFieldTest4.b = 0x14;
    bitFieldTest4.c = 0x5;
    bitFieldTest4.d = 0xc3f1794a;
    bitFieldTest4.e = 0xcceeffaa;

    bitFieldTest5.a = 0x1;
    bitFieldTest5.b = 0x14;
    bitFieldTest5.c = 0x5;
    bitFieldTest5.d = 0xc3f1794a;
    bitFieldTest5.e = 0xcceeffaa;

    bitFieldTest6.a = 0x1;
    bitFieldTest6.b = 0x14;
    bitFieldTest6.c = 0x5;
    bitFieldTest6.d = 0xc3f1794a;
    bitFieldTest6.e = 0xcceeffaa;

    printf("\nbitFieldTest1 ");
    struc_print((char *)&bitFieldTest1, sizeof(bitFieldTest1));
    print_analy1(&bitFieldTest1);
    printf("\nbitFieldTest2 ");
    struc_print((char *)&bitFieldTest2, sizeof(bitFieldTest2));
    print_analy2(&bitFieldTest2);
    printf("\nbitFieldTest3 ");
    struc_print((char *)&bitFieldTest3, sizeof(bitFieldTest3));
    print_analy3(&bitFieldTest3);
    printf("\nbitFieldTest4 ");
    struc_print((char *)&bitFieldTest4, sizeof(bitFieldTest4));
    print_analy4(&bitFieldTest4);
    printf("\nbitFieldTest5 ");
    struc_print((char *)&bitFieldTest5, sizeof(bitFieldTest5));
    print_analy5(&bitFieldTest5);
    printf("\nbitFieldTest6 ");
    struc_print((char *)&bitFieldTest6, sizeof(bitFieldTest6));
    print_analy6(&bitFieldTest6);

    return 0;
}
2. 运行结果
小端运行(intel i3):
bitFieldTest1 binary output: 01010101(55) 10101000(a8) 11110010(f2) 01011111(5f) 00000000(00) 11110001(f1) 00001111(0f) 00000000(00) 
Little-Endian Analysis:
Expand order:0001010101, 0010101010, 00000000010111111111, 000000000000111111110001
High->Low:00000000,00001111,11110001,00000000,01011111,11110010,10101000,01010101,
Byte Order(Low->High):01010101(55),10101000(a8),11110010(f2),01011111(5f),00000000(00),11110001(f1),00001111(0f),00000000(00),

bitFieldTest2 binary output: 01010001(51) 10100101(a5) 10010100(94) 00010111(17) 00111111(3f) 00001100(0c) 00000000(00) 00000000(00) 
Little-Endian Analysis:
Expand order:01, 010100, 0101, 0000000000000000000011000011111100010111100101001010
High->Low:00000000,00000000,00001100,00111111,00010111,10010100,10100101,01010001,
Byte Order(Low->High):01010001(51),10100101(a5),10010100(94),00010111(17),00111111(3f),00001100(0c),00000000(00),00000000(00),

bitFieldTest3 binary output: 01010001(51) 00000101(05) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 
Little-Endian Analysis:
Expand order:01, 010100, 0101, 0000000000000000000000000000000000000000000000000000
High->Low:00000000,00000000,00000000,00000000,00000000,00000000,00000101,01010001,
Byte Order(Low->High):01010001(51),00000101(05),00000000(00),00000000(00),00000000(00),00000000(00),00000000(00),00000000(00),

bitFieldTest4 binary output: 01010001(51) 00000101(05) 00000000(00) 00000000(00) 10101010(aa) 11111111(ff) 11101110(ee) 11001100(cc) 01001010(4a) 01111001(79) 11110001(f1) 11000011(c3) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 
Little-Endian Analysis:
Expand order:01, 010100, 0101, 00000000000000000000, 11001100111011101111111110101010, 0000000000000000000011000011111100010111100101001010, 000000000000
High->Low:00000000,00000000,00000000,00000000,11000011,11110001,01111001,01001010,11001100,11101110,11111111,10101010,00000000,00000000,00000101,01010001,
Byte Order(Low->High):01010001(51),00000101(05),00000000(00),00000000(00),10101010(aa),11111111(ff),11101110(ee),11001100(cc),01001010(4a),01111001(79),11110001(f1),11000011(c3),00000000(00),00000000(00),00000000(00),00000000(00),

bitFieldTest5 binary output: 01010001(51) 00000101(05) 00000000(00) 00000000(00) 10101010(aa) 11111111(ff) 11101110(ee) 11001100(cc) 01001010(4a) 01111001(79) 11110001(f1) 11000011(c3) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 
Little-Endian Analysis:
Expand order:01, 010100, 0101, 00000000000000000000, 11001100111011101111111110101010, 0000000000000000000011000011111100010111100101001010, 000000000000
High->Low:00000000,00000000,00000000,00000000,11000011,11110001,01111001,01001010,11001100,11101110,11111111,10101010,00000000,00000000,00000101,01010001,
Byte Order(Low->High):01010001(51),00000101(05),00000000(00),00000000(00),10101010(aa),11111111(ff),11101110(ee),11001100(cc),01001010(4a),01111001(79),11110001(f1),11000011(c3),00000000(00),00000000(00),00000000(00),00000000(00),

bitFieldTest6 binary output: 01010001(51) 00000101(05) 00000000(00) 00000000(00) 10101010(aa) 11111111(ff) 11101110(ee) 11001100(cc) 01001010(4a) 01111001(79) 11110001(f1) 11000011(c3) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 
Little-Endian Analysis:
Expand order:01, 010100, 0101, 00000000000000000000, 11001100111011101111111110101010, 0000000000000000000011000011111100010111100101001010, 000000000000
High->Low:00000000,00000000,00000000,00000000,11000011,11110001,01111001,01001010,11001100,11101110,11111111,10101010,00000000,00000000,00000101,01010001,
Byte Order(Low->High):01010001(51),00000101(05),00000000(00),00000000(00),10101010(aa),11111111(ff),11101110(ee),11001100(cc),01001010(4a),01111001(79),11110001(f1),11000011(c3),00000000(00),00000000(00),00000000(00),00000000(00),

大端分析(powerPc T2080):
bitFieldTest1 binary output: 00000000(00) 00001111(0f) 11110001(f1) 00000000(00) 01011111(5f) 11110010(f2) 10101000(a8) 01010101(55) 
Big-Endian Analysis:
Expand order:000000000000111111110001, 00000000010111111111, 0010101010, 0001010101
High->Low:00000000,00001111,11110001,00000000,01011111,11110010,10101000,01010101,
Byte Order(Low->High):00000000(00),00001111(0f),11110001(f1),00000000(00),01011111(5f),11110010(f2),10101000(a8),01010101(55),

bitFieldTest2 binary output: 00000000(00) 00000000(00) 00001100(0c) 00111111(3f) 00010111(17) 10010100(94) 10100101(a5) 01010001(51) 
Big-Endian Analysis:
Expand order:0000000000000000000011000011111100010111100101001010, 0101, 010100, 01, High->Low:00000000,00000000,00001100,00111111,00010111,10010100,10100101,01010001,
Byte Order(Low->High):00000000(00),00000000(00),00001100(0c),00111111(3f),00010111(17),10010100(94),10100101(a5),01010001(51),

bitFieldTest3 binary output: 01010101(55) 00010000(10) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 00000000(00) 
Big-Endian Analysis:
Expand order:0101, 010100, 01, 0000000000000000000000000000000000000000000000000000
High->Low:01010101,00010000,00000000,00000000,00000000,00000000,00000000,00000000,
Byte Order(Low->High):01010101(55),00010000(10),00000000(00),00000000(00),00000000(00),00000000(00),00000000(00),00000000(00),

bitFieldTest4 binary output: 00000000(00) 00000000(00) 00001100(0c) 00111111(3f) 00010111(17) 10010100(94) 10100000(a0) 00000000(00) 11001100(cc) 11101110(ee) 11111111(ff) 10101010(aa) 01010101(55) 00010000(10) 00000000(00) 00000000(00) 
Big-Endian Analysis:
Expand order:0000000000000000000011000011111100010111100101001010, 000000000000, 11001100111011101111111110101010, 0101, 010100, 01, 00000000000000000000
High->Low:00000000,00000000,00001100,00111111,00010111,10010100,10100000,00000000,11001100,11101110,11111111,10101010,01010101,00010000,00000000,00000000,
Byte Order(Low->High):00000000(00),00000000(00),00001100(0c),00111111(3f),00010111(17),10010100(94),10100000(a0),00000000(00),11001100(cc),11101110(ee),11111111(ff),10101010(aa),01010101(55),00010000(10),00000000(00),00000000(00),

bitFieldTest5 binary output: 00000000(00) 00000000(00) 00001100(0c) 00111111(3f) 00010111(17) 10010100(94) 10100000(a0) 00000000(00) 11001100(cc) 11101110(ee) 11111111(ff) 10101010(aa) 01010101(55) 00010000(10) 00000000(00) 00000000(00) 
Big-Endian Analysis:
Expand order:0000000000000000000011000011111100010111100101001010, 000000000000, 11001100111011101111111110101010, 0101, 010100, 01, 00000000000000000000
High->Low:00000000,00000000,00001100,00111111,00010111,10010100,10100000,00000000,11001100,11101110,11111111,10101010,01010101,00010000,00000000,00000000,
Byte Order(Low->High):00000000(00),00000000(00),00001100(0c),00111111(3f),00010111(17),10010100(94),10100000(a0),00000000(00),11001100(cc),11101110(ee),11111111(ff),10101010(aa),01010101(55),00010000(10),00000000(00),00000000(00),

bitFieldTest6 binary output: 00000000(00) 00000000(00) 00001100(0c) 00111111(3f) 00010111(17) 10010100(94) 10100000(a0) 00000000(00) 11001100(cc) 11101110(ee) 11111111(ff) 10101010(aa) 01010101(55) 00010000(10) 00000000(00) 00000000(00) 
Big-Endian Analysis:
Expand order:0000000000000000000011000011111100010111100101001010, 000000000000, 11001100111011101111111110101010, 0101, 010100, 01, 00000000000000000000
High->Low:00000000,00000000,00001100,00111111,00010111,10010100,10100000,00000000,11001100,11101110,11111111,10101010,01010101,00010000,00000000,00000000,
Byte Order(Low->High):00000000(00),00000000(00),00001100(0c),00111111(3f),00010111(17),10010100(94),10100000(a0),00000000(00),11001100(cc),11101110(ee),11111111(ff),10101010(aa),01010101(55),00010000(10),00000000(00),00000000(00),
3. 分析结论

  1. 无论大小端平台，位域的顺序是不变的，即前面的成员是低位、后面的成员是高位；

  2. 小端平台，位域结构体的存储规则

    小端模式下，不满 8 位的成员，需要和后面的成员组成 8 位，组成的原则是：位域中的低位置成员在连接中处于低位；当按照 8 位字节组成后，整个结构体需要按照“低位存放在低地址”进行存储。

  3. 大端平台，位域结构体的存储规则

    大端模式下，不满 8 位的成员，需要和后面的成员组成 8 位，组成的原则是：位域中的低位置成员在连接中处于高位；当按照 8 位字节组成后，整个结构体需要按照“低位存放在低地址”进行存储。（注意：也就是说在位域结构体中，大端和小端体现出的差异只是在进行 1byte 对齐时的顺序，存放都是按照”从低位到高位“进行存储的）

  4. 对“位域”位数之和是 byte 对齐的结构，大小端平台通过一些倒序是可以进行同样存储适合移植的，比如：

在这里插入图片描述

注意：这里倒序必须是在 1 个 byte 之内！！！！否则处理也是会有问题的

  1. 在需要进行大小端平台通信或者方便移植的代码中，不建议使用“位域”结构体，使用 offset + mask 的编码进行替代。
water-moon
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言输出居中对齐_一文轻松理解内存对齐
weixin_39940957的博客
11-29 3654
什么是内存对齐 元素是按照定义顺序一个一个放到内存中去的，但并不是紧密排列的。从结构体存储的首地址开始，每个元素放置到内存中时，它都会认为内存是按照自己的大小（通常它为4或8）来划分的，因此元素放置的位置一定会在自己宽度的整数倍上开始，这就是所谓的内存对齐。 编译器为程序中的每个“数据单元”安排在适当的位置上。C语言允许你干预“内存对齐”。如果你想了解更加底层的秘密，“内存对齐”对你就不应该再模糊...
C语言位域
c453787298的专栏
10-15 686
为什么要有位域：            数据在存储时并不需要占用一个完整的字节，只需要几个或一个二进制位，为了节省空间，并处理简单，C语言提供了位域。 例如： struct bs {int a:8;int b:2;int c:6;}; 要点：        1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单
走进结构体存储--位域
轻飘飞扬
03-17 5370
1、位域简介        在嵌入式编程中，经常会遇到下面的结构：struct _data { char a:6; char b:2; char c:7; }data;       在存储信息的时候，我们可能并不需要占用一个完整的字节，而只需占一个或几个二进制位，如要存储一个八进制数据，只需要3 个二进制位就够了。为了节省存储空间，C 语言提供了位域这种数据结构。所谓
位域结构存储和读取
mkchiny的博客
06-19 293
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <fcntl.h> #include <unistd.h> #include <time.h> #define DEBUG(fmt, arg...) printf("\033[32m[%s:%d]\033[36m"fmt"\033[0m", __
位域
qq_1070971363的博客
06-29 755
　有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位...
位域结构体在内存中的存放方式
hhhlizhao的博客
08-06 537
如下
c代码-C结构体06：位域（就是取值范围 :2 ）、内存对齐、内存中的存储、内存地址
07-16
在“C代码-C结构体06：位域（就是取值范围 :2 ）、内存对齐、内存中的存储、内存地址”这个主题中，我们将探讨几个关键的概念，这些概念对于理解和优化C程序的内存使用至关重要。 首先，让我们来了解**位域**。位域...
嵌入式系统开发人员C语言测试题-内存管理.doc
06-13
在嵌入式系统开发中，C语言是常用的语言，而内存管理是C语言编程中至关重要的一环。此测试题主要涵盖了以下几个知识点： 1. **动态内存分配**： - `(char *)malloc(0)` 分配0字节的内存，根据C标准，`malloc(0)`...
Crash问题分析，总结objdump使用方式
06-11
在 Crash 问题分析中，我们可以使用 objdump 工具来dump 崩溃的进程的内存信息，然后对内存信息进行分析，找到崩溃的原因。 Crash 问题分析和 objdump 使用方式是软件开发和测试中非常重要的一部分，对于提高软件...
C/C++ 大小端、位域、内存详解
烛火飞蛾
06-25 762
前言 面试时遇到关于大小端、位段（或者叫位域）和内存对齐的考题，然后就不知所措了。这部分对于嵌入式底层工作者是必须要掌握的，其他方面不是必须的；但还是很有必要学习理解这些知识点，因为它可以让你更了解C++的,了解程序在内存的运行情况，也能加深对计算机系统的理解。 1、大小端 在现代的“冯.诺依曼体系结构”计算机中，计算机内的数制都是采用二进制来存储，并且是以8位，一个字节为...
位域占用内存大小测试
科技改变世界
04-09 374
// 位域内存测试 #include <STDIO.H> struct ONE_BYTE { unsigned char _bool : 1; unsigned char del_flag : 1; unsigned char status : 4; } one_byte; struct TWO_BYTE { unsigned char ccc1 :...
C 语言结构体及位域内存大小
weixin_45653012的博客
11-06 957
C 语言结构体及位域内存大小 小白一枚，最近线学习野火stm32,写个博客记录下自己学习之路。 以下资料来自野火论坛以及其他网站。 存对齐的规则很简单： 1.起始地址为该变量类型所占内存的整数倍，若不足则不足部分用数据填充至所占内存的整数倍。 2.该结构体所占总内存为结构体成员变量中最大数据类型的整数倍。 一.看如下例子：（假设char 是 1个字节，double是8个字节，int是2个字节 ，f...
C++内存字节对齐与位域【你可能不知道的C++】
高万禄的博客
10-26 1056
如果你是一位嵌入式工程师可能会更熟悉，类或结构体可以将非静态数据成员定义为位域，每个位域含有一定的二进制位，通常用于串口通信等，位域在内存的布局与机器相关。6、如果相邻位域字段的类型相同，且其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；5、如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；上面有学习过结构体中的字节对齐问题，那么含有位域的结构体的内存对齐情况又是怎样的呢？
计算机是如何存储一个跨字节对象的？
weixin_34329187的博客
01-28 157
2019独角兽企业重金招聘Python工程师标准>>> ...
位域+跨字节成功
qq_37218325的博客
05-19 497
位域+跨字节成功 提示：建议先看本人写的《位域+跨字节失败》博客 跨字节读取成功示例 结构体消息定义 消息解析 3. 输出 跨字节读取成功示例二 消息定义 消息解析（同示例一相同） 输出 注：此时的ptr->a占7bit，ptr->b会读取第0个字节中的最后一位，接着读取15位。 ...
C语言 位域的使用
a只如初见的博客
06-15 3730
目录什么是位域位域的定义位域的使用使用位域的注意点（重要）实际应用 什么是位域 有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。为了节省存储空间，并使处理简便，C 语言又提供了一种数据结构，称为"位域"或"位段"。 所谓"位域"是把一个字节中的二进制位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。 典型的应用场
C语言 -- 位段（位域）
MonologueYY的博客
12-13 1582
什么是位段 ···· 位段的内存分配 ···· 位段的跨平台问题
C 位域结构体的内存分布
最新发布
06-19
C 语言中的位域（bit-field）结构体是一种特殊的成员，它可以将一个结构体中的连续位（bit）用于存储单个的值，即使这个值可能占用的位数少于整个字段的大小。内存分布时，位域结构体会按照以下方式处理： 1. 内存...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值