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. 分析结论
无论大小端平台,位域的顺序是不变的,即前面的成员是低位、后面的成员是高位;
小端平台,位域结构体的存储规则
小端模式下,不满 8 位的成员,需要和后面的成员组成 8 位,组成的原则是:位域中的低位置成员在连接中处于低位;当按照 8 位字节组成后,整个结构体需要按照“低位存放在低地址”进行存储。
大端平台,位域结构体的存储规则
大端模式下,不满 8 位的成员,需要和后面的成员组成 8 位,组成的原则是:位域中的低位置成员在连接中处于高位;当按照 8 位字节组成后,整个结构体需要按照“低位存放在低地址”进行存储。(注意:也就是说在位域结构体中,大端和小端体现出的差异只是在进行 1byte 对齐时的顺序,存放都是按照”从低位到高位“进行存储的)
对“位域”位数之和是 byte 对齐的结构,大小端平台通过一些倒序是可以进行同样存储适合移植的,比如:
注意:这里倒序必须是在 1 个 byte 之内!!!!否则处理也是会有问题的
- 在需要进行大小端平台通信或者方便移植的代码中,不建议使用“位域”结构体,使用 offset + mask 的编码进行替代。