c语言基础（八）

字节对齐

结构体内成员对齐规则：
1、我们的结构体变量本身就是在4字节对齐的位置,编译器帮我们做的事。
2、第一个成员，就从结构体开始的地址处，存放。这个元素，具体占多少字节，由紧挨着下个元素决定。
3、整个成员变量自身都对齐 了，还没有结束。
4、整个结构体还要是默认字节对齐的最小整数倍。
结构体默认的字节对齐：成员变量最大的那个类型所占字节

#include<stdio.h>

typedef struct data
{
        int a;               // 4
        char b;             // 1 + 1（填充）
        short c;           // 2    最后整个结构体自身还要对齐
}D;
int main(void)
{
    printf("sizeof(D)=%d.\n",sizeof(D));
    return 0;
}
结果为8byte

注意：

struct data
{
    int a;
    struct data s;   // 1.此时结构体类型(定义)不完整  2.C语言不允许
}s;

int main(void)
{
    unsigned short a = 0x1234;  
    unsigned char * p1 = (unsigned char *)&a, i = 8;
    //*p1 << i,就产生了临时变量，内存中你不知道地址，但是有一个默认类型(int)
    printf("sizeof(*p1 << i) = %d.\n", sizeof(*p1 << i));
    printf("0x%x.\n", *p1 <<= i);    // printf("%d.\n", a *= 2);
    printf("0x%x.\n", *(p1+1));
}
结果如下：sizeof(*p1 << i)=4
        0x0
        0x12

#include<stdio.h>

struct data
{
        int a;                              // 4 + 4(padding)

        struct data *p_next;              //64bit机器指针永远永远占8字节
}S;
int main(void)
{
    printf("sizeof(S)=%d.\n",sizeof(S));
    return 0;
}
结果为16byte

结构体的嵌套

#include<stdio.h>
struct data1
{
        int a;
        short b;
        int c;
        double e;
};//24

typedef struct data
{
        char a;//2
        short b;//2
        int c;//4
        struct data1 s;//24 
        char ch;//8
}S;

int main(void)
{
    printf("sizeof(S)=%d.\n",sizeof(S));
    return 0;
}
结果为40

字段对齐

位字段：专用于结构体，结构体成员的类型必须是：int || unsigned int
有时侯，结构体成员表示的数据很小，就用几个位来表示。
0字段，不可访问，只是占位整个字中剩下的位，全部写0
无名字段，不可访问，只是占位
字(word)=32bit
下一个字段不够在剩余的字存放时，必须另起一个字。字段不能跨字。
超出字段表示的数据范围，结果不可预期
若最后一个字没有填满则也将填满后返回
字段不可取地址

#include <stdio.h>
struct data1
{
    unsigned a : 1;     // 1就是一个bit，范围：0～1
    int : 31;           // 无名字段，不可访问，只是占位
    unsigned b : 2;     // 2就是2个bit，范围：0～3
    unsigned c : 2;   // 28位 
}s1;

int main(void)
{
    printf("szieof(s1) = %d.\n", sizeof(s1));
    return 0;
}
结果为8byte，同时也是2word

特别的是：

struct
{
    int a:1;//此时a只有一位且仅为符号位，取值范围为(-1~0)
};

对齐指令

#pragma pack(n) （1、2、4、8、.....）
#pragma pack()

这两个配合使用，表示一个区间，只有这个区间内的结构体享受这个待遇。
设置 对齐。
如果将n设置为1，就是不对齐
1、充分利用内存空间，牺牲了速度，降低了访问效率。
2、提高效率、性能，牺牲了内存空间。
总结：你指定的对齐方式和结构体自身默认对齐方式，俩者取最小的。

#include <stdio.h>
#include <stdlib.h>

#pragma pack(2)
struct data                 // 16
{
    int a;
    char b;
    double c;
}s;

struct data1
{
    char ch;
}s1;
#pragma pack()

检查系统错误的宏

一旦发生了，系统错误就会产生一个错误数字(errno)，对应相应的错误字符串。
C标准定义了两个值 EXIT_SUCCESS 和 EXIT_FAILURE，可以作为exit()的参数，来分别指示是否为成功退出。
exit(参数)传递给的是父进程，或者shell终端

#define handle_error(msg)   do{perror(msg); exit(EXIT_FAILURE);}while(0)

Linux内置宏

linux内核里的两个宏：在驱动应用中很广泛。
off_set_of(type, member)计算结构体内元素的偏移量
containe_of(ptr, type, member),ptr是结构体里成员的指针，通过调用这个宏计算出结构体的首地址.包含两句代码(表达式)，必须要加{}.
这两个宏：内核双链表。

分析：
#define off_set_of(type, member)  ((long)&(((type *)0)->member))
1、（type *）0指向结构体零地址                                         
2、(（type *）0)->member得到了结构体某个成元变量名    
3、给这成员变量名，取地址(相对于零地址)，此时&(((type *)0)->member)表示是指针类型 
4、强制类型转换成(long)

#define container_of(ptr, type, member)   ({typeof(((type *)0)->member) *_mptr = ptr;(type *)((char *)_mptr-off_set_of(type, member));})
1、得到结构体成员变量的类型
2、指针赋值(得到真实成员变量的地址值)
3、减去偏移量得到一个数字，该数字和结构体本身首地址在数值上一样
4、最后强制类型转换为结构体指针类型

举个栗子：

#include <stdio.h>

#define off_set_of(type, member)  ((long)&(((type *)0)->member))
#define container_of(ptr, type, member)     ({typeof(((type *)0)->member) *_mptr = ptr;(type *)((char *)_mptr-off_set_of(type, member));})

struct da
{
    int a;
    short b;    
    int c;
    double e;
};                      // 16
struct data
{
    char a;
    short b;
    int c;              // 8
    struct da s;    // 16
    char ch;
}s = {1, 3, 10, 3.14, 1.41};
//1、不会因为有结构体成员，而影响你的基本类型，决定默认对齐
//2、里面的结构体对齐方式，已经在外面决定了(遍历整个完整结构体)

int main(void)
{
    printf("sizeof(s) = %d.\n", sizeof(s));
    //结构体自身的首地址
    printf("&s = %p.\n", &s);
    struct da *p = container_of(&s.s.b, struct da, b);
    printf("p = %p.\n", p);
    printf("&s.s = %p.\n", &s.s);
    return 0;
}
p->a == (struct data *)0->a;
/*
//让你明白强制转换0地址
struct data *p;     
unsigned long a = 0;        
p = (struct data *)a;  
p->a == (struct data *)0->a;
*/

关于typeof

typeof（），（）里面的参数可以是变量名或者表达式。
typeof(int) p

int *p, a;
typeof(p) p_a = &a;//将p_a的类型转换为p的类型，即指针类型