C语言--解析结构体

1.结构体的声明

结构是一些值的集合，这些值称为成员变量，而且每个成员变量可以为不同类型的变量。

struct tag
{
    member-list;
}variable-list;

例如描述一个人：

struct Pen
{
    char name[20];//姓名
    int age;//年龄
    char sex[8];//性别
};//分号不能丢

特殊的声明：

在声明结构的时候，可以不完全声明。例如：

struct 
{
    int a;
    char b;
    float c;
}x[20],*y;

struct
{
    int a;
    char b;
    float c;
}a;

可以省略掉tag标签符号。现在问题来了:在上述代码的基础下，y=&a 合法吗？

 

答案是不合法的，编译器会把这两个声明当成不同的两个类型。

2.结构体的自引用

前面既然说过了结构体中可以存不同类型的数据，那么是否可以包含一个类型为该结构体本身的成员呢？

struct Node
{
    int a;
    struct Node b;
};

 这种写法是否可行呢？假如我们说他是可行的，但是sizeof(struct Node)是多少？好像说不通吧，要一直无限递归下去。所以我们改进一下写法：

struct Node
{
    int a'
    struct Node* b;
};

将指针存放在结构体中，可以通过指针找到结构体，这样它的大小也就能够确定了。

注意: 

typeof struct
{
    int a;
    Node* b;
}Node;
//这样写是否正确？编译器在编译时是按顺序来的，是不知道结构体中的Node是什么类型的。所以这是错误的。

//正确：
typeof struct Node
{
    int a;
    struct Node* b;
}Node;

3.结构体变量的定义和初始化

struct Point
{
    int x;
    int y;
}p1; //声明类型的同时定义变量p1

struct Point p2; //定义结构体变量p2

struct Point p3 = {x, y};    //初始化：定义变量的同时赋初值。



struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};

struct Stu s = {"zhangsan", 20};//定义变量同时初始化



struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

4.结构体内存对齐

struct S1
{
    char a;
    int b;
    char c;
};
printf("%d\n",sizeof(struct S1));

 大家先猜测一下答案会是什么。如果是6那就错了，结构体的大小并不是内部成员大小的简单相加。运行程序可得答案为： 

接下来看一个在结构体中比较重要的概念--内存对齐。

怎么计算结构体的大小，首先要知道结构体的对齐规则：

1. 第一个成员在结构体变量偏移量为0的地址处；
2. 其他的成员要对齐到结构体变量偏移量为(自己的)对齐数的整数倍的地址处 
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

ps：对齐数=编译器默认的一个对齐数 和 该成员大小的较小值。vs默认值为8。

 以上述代码为基础再结合对齐规则，现在我画图来解释到底是怎么对齐的：

1.第一个变量a放在偏移量为0的地方占一个字节；

 2.b为int型，四个字节。而在vs中默认对齐数为8，对齐数取其较小值，所以对齐数为4，根据第二条规则，对齐到其对齐数整数倍处，最小整数倍为4。而b占四个字节；

 3.而c为char类型，根据第二条规则，对齐数为1，所以c在偏移量为8的地方。这时被占取得大小为9个字节，根据第三条规则，结构体大小应该为最大对齐数整倍数。最大对齐数为4，那么这时最小的整数倍应该为12，所以结构体大小应该为12。

 再看一个例题：

struct S1
{
    double a；
    char b;
    int c;
};

struct S2
{
    char d;
    struct S1 s;
    double e;
};
printf("%d\n",sizeof(struct S2));

 根据对齐规则自己试一试。

为什么会存在数据对齐？

1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

简单来说，结构体的内存对齐就是拿空间来换取时间的做法。

 在设计结构体时，在对齐的同时，如何尽可能地节省空间呢？让占用空间比较小的成员尽量集中在一起。

struct S1
{
    char c1;
    int i;
    char c2;
};
struct S2
{
    char c1;
    char c2;
    int i;
}

 通过计算和程序运行可以知道上面的设计形式占用空间是要大于下面的设计形式的。

5.修改默认对齐数

可以通过#pragma预处理指令改变默认对齐数。

#pragma pack(2)//设置默认对齐数为2
struct S1
{
    char c1;
    int i;
    char c2;
};
printf("%d\n",sizeof(struct S1));
#pragma pack()//取消设置的默认对齐数，还原为默认

struct S1
{
    char c1;
    int i;
    char c2;
};
printf("%d\n",sizeof(struct S1));

运行程序可以得到两段代码的运行结果分别为:

所以结构体在对齐方式不合适时，可以自己修改默认对齐数，不过一般都是修改成1,2,4,8这样的数。需要注意的是，如果将其修改成1那么就相当于取消了内存对齐这一概念。

6.结构体传参

结构体还可以作为函数的参数传参：

struct S
{
	int num[10];
	char a;
};

struct S s = { {1,2,3,4},'a' };

void print1(struct S s)
{
	printf("%c\n", s.a);
}

void print2(struct S* ps)
{
	printf("%c\n",ps->a);
}

int main()
{
	print1(s);//传结构体
	print2(&s);//传地址
	return 0;
}

分析上面的代码，你认为print1函数好还是print2函数好？

我们知道，为形式参数开辟空间时是在内存中的栈区开辟的。函数参数传参时，参数会压栈，会有时间和空间上的开销。

如果传递一个结构体为参数时，结构体是比较大的，参数压栈时系统的开销比较大，所以会使效率性能大大下降，所以在传参时最好传结构体的地址。