C语言学习记录—进阶作业4（结构体大小计算）

1. 在32位系统环境，编译选项为4字节对齐，那么sizeof(A)和sizeof(B)是()

struct A
{
	int a;//0~3
	short b;//4~5
	//6~7
	int c;//8~11
	char d;//偏移量12
	//13~15
	//0~12有13个字节，最大对齐数4，所以结构体大小是16(得是最大对齐数的倍数）
};

struct B
{
	int a;//0~3
	short b;//4~5
	char c;//6
	//7
	int d;//8~11
	//0~11有12个字节，最大对齐数4，所以结构体大小是12(得是最大对齐数的倍数）
};
//A.16, 16
//B.13, 12
//C.16, 12
//D.11, 16
//答案：C 

2. 下面代码的结果是：（ ）

#pragma pack(4)/*编译选项，表示4字节对齐 平台：VS2013。语言：C语言*/
//假设long 是4个字节
int main(int argc, char* argv[])
{
    struct tagTest1
    {
        short a;//0~1
        char d;//2
        //3
        long b;//4~7
        long c;//8~11
    };
    struct tagTest2
    {
        long b;//0~3
        short c;//4~5
        char d;//6
        //7
        long a;//8~11
    };
    struct tagTest3
    {
        short c;//0~1
        //2~3
        long b;//4~7
        char d;//8
        //9~11
        long a;//12~15
    };
    struct tagTest1 stT1;
    struct tagTest2 stT2;
    struct tagTest3 stT3;

    printf("%d %d %d", sizeof(stT1), sizeof(stT2), sizeof(stT3));
    return 0;
}
#pragma pack()
//A.12 12 16
//B.11 11 11
//C.12 11 16
//D.11 11 16
//答案：A

3. 有如下宏定义和结构定义，当A=2， B=3时，pointer分配（ ）个字节的空间

#define MAX_SIZE A+B
struct _Record_Struct
{
	unsigned char Env_Alarm_ID : 4;//1byte-8bit
	unsigned char Para1 : 2;
	unsigned char state;//1byte-8bit
	unsigned char avail : 1;//1byte-8bit
}*Env_Alarm_Record;
struct _Record_Struct* pointer = (struct _Record_Struct*)malloc(sizeof(struct _Record_Struct) * MAX_SIZE);
//A.20
//B.15
//C.11
//D.9
//答案：D - 结构体3个字节乘以MAX_SIZE，即3*2+3

4. 下面代码的结果是（ ）

#include <string.h>
int main()
{
    unsigned char puc[4];
    struct tagPIM
    {
        unsigned char ucPim1;
        unsigned char ucData0 : 1;
        unsigned char ucData1 : 2;
        unsigned char ucData2 : 3;
    }*pstPimData;
    pstPimData = (struct tagPIM*)puc;
    memset(puc, 0, 4);
    pstPimData->ucPim1 = 2;
    pstPimData->ucData0 = 3;
    pstPimData->ucData1 = 4;
    pstPimData->ucData2 = 5;
    printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]);//%x十六进制形式打印，02打印两位，不够用0填充
    return 0;
}
//A.02 03 04 05
//B.02 29 00 00
//C.02 25 00 00
//D.02 29 04 00
//答案：B
//puc是unsigned char数组，有4个元素，且全部被初始化为0
//再用结构体指针将该数组指针强制类型转换为结构体指针
//puc数组占4个字节，tagPIM结构体(位段)占2个字节
//结构体各成员二进制：ucPim1 - 10(占8bit) ； ucData0 - 11(占1bit) ；ucData1 - 100(占2bit) ； ucData2 - 101(占3bit)
//且位段对于一个字节内的比特位是从低位到高位
//00000000 00000000 00000000 00000000 - puc数组
//00000010 00000000 00000000 00000000 - 将2存到ucPim1
//00000010 0000000 1 00000000 00000000 - 将3存到ucData0
//00000010 00000 00 1 00000000 00000000 - 将4存到ucData1
//00000010 00 101 00 1 00000000 00000000 - 将5存到ucData2
//   00        29         00       00 - 十六进制表示

5. 在VS2013下，默认对齐数为8字节，这个结构体所占的空间大小是（ ）字节

typedef struct {
	int a;//0~3
	char b;//4
	//5
	short c;//6~7
	short d;//8~9
	//10~11
}AA_t;
//A.16
//B.9
//C.12
//D.8
//答案：C

6. 下面代码的结果是：（ ）

union Un
{
	short s[7];//占用14个字节，对齐数2
	int n;//占用4个字节，对齐数4
};
int main()
{
	printf("%d\n", sizeof(union Un));
	return 0;
}
//A.14
//B.4
//C.16
//D.18
//答案：C

7. 在X86下，小端字节序存储，有下列程序

int main()
{
    union
    {
        short k;
        char i[2];
    }*s, a;
    s = &a;
    s->i[0] = 0x39;
    s->i[1] = 0x38;
    printf("%x\n", a.k);
    return 0;
}
//A.3839
//B.3938
//C.380039
//D.不确定
//答案：A
//00000039 00000038 - i和k公用2个字节
//假设左边低地址，右边高地址
//小端【字节序】存储：把一个数据的高位字节序的内容放在高地址处，把低位字节序放在低地址处
//39在低地址处，38在高地址处，39是低位字节，38是高位字节。所以是3839

8. 在X86下，小端字节序存储，有下列程序

int main()
{
    union
    {
        short k;
        char i[2];
    }*s, a;
    s = &a;
    s->i[0] = 0x39;
    s->i[1] = 0x38;
    printf("%x\n", a.k);
    return 0;
}
//A.3839
//B.3938
//C.380039
//D.不确定
//答案：A
//00000039 00000038 - i和k公用2个字节
//假设左边低地址，右边高地址
//小端【字节序】存储：把一个数据的高位字节序的内容放在高地址处，把低位字节序放在低地址处
//39在低地址处，38在高地址处，39是低位字节，38是高位字节。所以是3839

9. 下面代码的结果是：（ ）

enum ENUM_A
{
	X1,
	Y1,
	Z1 = 255,
	A1,
	B1,
};
enum ENUM_A enumA = Y1;
enum ENUM_A enumB = B1;
printf("%d %d\n", enumA, enumB);
//A.1, 4
//B.1, 257
//C.2, 257
//D.2, 5
//答案：B