C语言常见陷阱之“纠缠不清的位域”

一.表达式求值--整数类型提升

问题：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
    char c;
    unsigned char uc;
    unsigned char us;
    c = 128;// -128-0-127;
    uc = 128;
    us = c + uc;//256;
    printf("0x%x\n", us);
    us = (unsigned char)c + uc;
    printf("0x%x\n", us);
    us = c + (char)uc;
     printf("0x%x\n", us);
    system("pause");
    return 0;
}

输出的结果是（）

A :0x0 0x00 0xff00

B :0x100 0x100 0xff00

C:0x00 0x100 0x0

D:0x0 0x100 0x0

答案是A.

首先要搞明白为什么会出现整形类型提升；

C的整形算数表达式运算时总是至少以缺省整形类型的精度来进行计算，为了获得这个精度，将字符型和短整形操作数在使用之前转换为普通整形；这种转换成为是整形提升，然后再执行算数运算，最后将结果截断放到内存中；

接下来我们仔细分析下：如下

int main()
{
    char c;
    unsigned char uc;
    unsigned char us;
    c = 128;// -128-0-127;
    uc = 128;
    us = c + uc;//256;
      c是有符号型最高位是符号位1111 1111  1111 1111  1111 1111  1000 0000
      uc是无符号                        0000 0000  0000 0000  0000 0000  1000 0000
                                              0000 0000  0000 0000  0000 0000  0000 0000
    最后的结果截断ox表示16进制取后16位结果是oxoo
     10000 0000无符号取低八位；为0；
    printf("0x%x\n", us);

    us = (unsigned char)c + uc;
      强制后c    0000 0000  0000 0000  0000 0000  1000 0000
      uc            0000 0000  0000 0000  0000 0000  1000 0000
                     0000 0000  0000 0000  0000 0001  0000 0000
    结果截断表示ox0f00;
    printf("0x%x\n", us);

    us = c + (char)uc;
    c是有符号型最高位是符号位    1111 1111  1111 1111  1111 1111  1000 0000
    uc是有符号型最高位是符号位   1111 1111  1111 1111  1111 1111  1000 0000
                                 1111 1111  1111 1111  1111 1111  0000 0000
    结果截断表示ox0ff00
    printf("0x%x\n", us);
    system("pause");
    return 0;
}

2.static关键字的使用：

static修饰变量。作用于仅仅局限于被定义的文件中，防止被其他文件调用；

修饰全局变量。作用域在定义处开始，知道文件结尾处结束；

修饰局部变量，在函数体被定义，只能在这个函数里用。

int fun(int x, int y)
{
    static int m = 0;
    static int i = 2;
    i += m + 1;//3
    //第二次8+3+1
    m = i + x + y;//3+x+y
    //第二次12+4+1
    return m;//8
}
int main()
{
    int j = 4;
    int m = 1;
    int k;//k = 8
    k = fun(j, m);// 4 1
    printf("%d\n", k);
    k = fun(j, m);//4 1
    printf("%d\n", k);
    system("pause");
    return 0;
}

结果是 8和17；

第一次调用fun函数时，x= 4,y = 1;i = 3;m = 3+4+1= 8;

第二次调用fun函数时，x=4；y= 4；i= 3+8+1 =12；m =12+4+1 = 17；

3.“指针+1”的妙用。

struct B
{
    long A1;
    char cA2;
    char cA3;
    long A4;
    long A5;
}*p;
  p = (struct B*)0x100000;
  p + 0x1 = 100001;
  (unsigned long)p + 0x1 = 0x100001;
  (unsigned long*)p +0x1 = 0x100004;
  (char *)p + 0x1 = 0x100004;

接下来我们分析一下+1实际是加几？

struct B
{
    long A1; //4
    char cA2; //1
    char cA3; //1
    long A4; //4
    long A5; //4
}*p;
//4+1+1+2+4+4  = 16
    p = (struct B*)0x100000;
    p + 0x1 = 100010;

    p此时表示结构体首地址 + 1 = sizeof(struct B)+0x100000 = 0x100010； 

 (unsigned long)p + 0x1 = 0x100001;

    表示p强转为unsigned long整型此时表示值+1 = sizeof(unsigned long)+0x10000=0x100001    

(unsigned long*)p +0x1 = 0x100004

    表示p强转为unsigned long *结果表示指针+1 =sizeof(unsigned long*) =  0x100004;

 (char *)p + 0x1 = 0x100004;

    p的类型强转为char*结构表示指针+1 = sizeof(char*)+0x00001 = x100004；

    一般这种的求法都是sizeof(类型)*i

我们详细分析下：还记得前面a+1和&a +1区别吗？指针变量与整数相加减表示指针的地址加上这个整数，而这个整数表示不是字节而是元素的个数。

所以第一个p +0x1表示是结构体的首地址+sizeof(struct B）= 0x100010;第2个表示将p强制转换成unsigned long 整形；此时(unsigned long)p + 0x1表示是值加1 = 0x100001；

第三个将p强制转换(unsigned long*）指针型，所以(unsigned long*)p + 0x1 = 0x100004；最后一个表示（char*)p 指针+0x1 = 0x100004

4.“纠缠不清的”位域。

#define MAX_SIZE A+B
struct _Record _Struct
{
    unsigned char E : 4;
    unsigned char p : 2;
    unsigned char stata;
    unsigned char a : 1;
}*p;
struct Record _Struct *p = (struct Record _Struct *p)malloc(szieof(struct Record _Struct)*MAX_SZIE);

当A = 2,B = 3时，p分配几个字节（）的空间

A 20， B 15， C 11， D 9

答案是D

位域：

有些信息在存储时并不需要占用一个完整的字节；而是占用一个或者几个二进制位，为了节省空间，并且使用方便，C语言提供了一种数据结构，称为位域。“位域”就是指把一个字节化成不同的区域，并且每个区域都有自己的位数；每个域都有自己的域名，允许程序按域名操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：     

struct 位域结构名     
{ 位域列表 };     

其中位域列表的形式为： 类型说明符 位域名：位域长度  ；

接下来分析这个题：E表示占用这个字节的前4个位，p占用这个字节后2个位；state表示一个完整的位段，还剩2个位不足以存储，需要重新开辟了新的字节，a占用第三个字节的第一位。

这样总共需要三个字节；所以这个结构体的大小是3个字节；

所以最后的结构就是3*3+3 = 9;这里面注意宏替换时，参数必须紧挨着参数列表，不然会被解释成两部分。 

struct tagAAA
{
    unsigned char a : 1;
    unsigned char b : 2;
    unsigned char c : 6;
    unsigned char d : 4;
    unsigned char e;
    unsigned char f : 4;
    unsigned char g;
}AAA_s;
int main()
{
    struct tagAAA ;
    printf("%d\n", sizeof(struct tagAAA));
        system("pause");
    return 0;
}

一字节对齐时按照char型来计算，四字节时按照int型来计算；

按照char型，前面位域的分析；a占1bit，还剩7bit，然后把b放进去，还剩5bit，c此时是6bit，不够，开辟一个新的字节；第二个字节还剩2bit，d占4bit需要重新开辟；e表示单独一个完整的字节；f占4bit,第五个字节还剩4bit；g是一个完整的字节；所以总共需要6字节；

按照int型分析:一个int有32位，所以a,b,c,d占一个字节，e是一个完整的字节，f需要单独开辟一个新字节；g表示一个完整的字节；

所以结果是AAA_s在1字节（char）和四字节(int)情况下，占用的字节大小分别是6和16

#pragma pack(4)
int main()
{
    struct tagPIM
    {
        unsigned char a;
        unsigned char b : 1;
        unsigned char c : 2;
        unsigned char d : 3;
    }*pstdata;
    unsigned char puc[4];
    pstdata = (struct tagPIM*)puc;
    memset(puc,0, 4);
    pstdata->a = 2;
    pstdata->b = 3;
    pstdata->c = 4;
    pstdata->d = 5;
    printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]);
    system("pause");
    return 0;
}

整个结构体占2字节，a是一个完整的字节，b表示位域 从最低位存开始，只占1位，c表示位域从最低位开始占两个位00，d占三个位，从最低位开始取三个位为101；其他的补零。

注意：此平台是小端，存储方式按照，最低位放低地址，最高位放高地址。

这样0x表示是16进制，所以此时很容易得到结果。