自定义类型——结构体（内存对齐详解）

结构体声明

• 声明结构如下

struct tag{         // tag 表示结构体标签
    member-list;    // member-list 表示结构体成员列表
}variable-list;     // variable-list 表示结构体变量列表

• 第一种常见声明如下

struct student {    // 声明了一个结构体类型 student
	char name[20];  // 结构体的成员
	int age;
	char sex[5];
	char id[20];
};  // 该封号不能省略

• 另一种常见声明是使用 typedef对结构体重命名

typedef struct student {
	char name[20];
	int age;
	char sex[5];
	char id[20];
}student;

未加 typedef 前，结构体变量的定义语句如下

    struct student s1;

加 typedef 后，结构体变量的定义语句如下

    student s1;

typedef 的作用是类型重命名，即将 struct student 重命名为 student ，可简化代码。

---

结构体特殊声明

• 在结构体声明时，省略掉了结构体标签（tag），进行不完全声明，不完全声明产生匿名结构体类型

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

• 要点一：匿名结构体只能使用一次

    p = &x; // 报错，类型不同

• 要点二：尽管上述两个结构体的成员相同，但编译器会把上面的两个声明当成完全不同的两个类型，因此无法将 x 的地址赋值给指针变量 p

---

结构体自引用

• 即在结构体声明时，在结构中包含一个类型为该结构本身的成员，使用方法如下

struct Node{
    int data;
    struct Node* next;
};

常见错误如下

struct Node{
    int data;
    struct Node next;
};

• 与正确写法相比，正确写法可知结构体成员 struct Node* next 的大小为4或8字节，而错误写法未知 struct Node 所占内存空间大小，无法明确结构体 Node 实际大小，故错误。

typedef struct{
    int data;
    Node* next;
}Node;

• 此自引用，在重命名 Node 前，先使用了 Node* ，系统会无法识别 Node* 的具体含义，会报错，正确写法如下

typedef struct Node{
    int data;
    struct Node* next;
}Node;

---

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

• 在声明结构体类型的同时，定义多个结构体变量S1,S2,S3

struct student {
	char name[20];
	int age;
	char sex[5];
	char id[20];
}S1,S2,S3;    // 结构体变量S1,S2,S3
// 等同于先声明，后创建
struct student S1,S2,S3;

• 初始化：定义变量的同时赋初值。

    struct student S4 = {"zhangsan", 18, "male", "12345678"};

• 结构体嵌套初始化

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

---

结构体成员访问

• 第一种是结构体变量访问成员，通过点操作符（.）访问

void print(struct student ps)  {
    printf("%s %d\n", ps.name, ps.age);
}

• 第二种是结构体指针访问指向变量的成员，使用指向结构体成员运算符（->）访问

void print(struct student* ps)  {
    printf("%s %d\n", (*ps).name, (*ps).age);
    // 使用结构体指针访问指向对象的成员
    printf("%s %d\n", ps->name, ps->age);
}
int main(){
    struct student s = {"zhangsan", 20};
    print(&s);  //结构体地址传参
    return 0;
}

---

结构体传参

• 分为结构体传参和结构体地址传参

struct S{
	int Num[10];
	int num;
};
struct S s1 = { {1,1,1,1}, 1000 };
// 结构体传参
void print1(struct S s){
	printf("%d\n", s.num);
}
// 结构体地址传参
void print2(struct S* ps){
	printf("%d\n", ps->num);
}
int main(){
	print1(s1);     // 传结构体
	print2(&s1);    // 传地址
	return 0;
}

---

结构体内存对齐

• 结构体内存对齐规则

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。（VS中默认的值为8）
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

• 举例如下

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

图中蓝色部分表示浪费的地址空间，其他颜色表示相应成员所占空间大小

#include <stddef.h>
int main() {
	printf("%u\n", offsetof(struct S1, c1));
	printf("%u\n", offsetof(struct S1, i));
	printf("%u\n", offsetof(struct S1, c2));
	return 0;
}

• offsetof 计算结构体成员相对起始地址的偏移量
  运行结果如下：

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

struct S3{
	double d;
	char c;
	int i;
};

struct S4{
	char c1;
	struct S3 s3;   // 结构体嵌套问题
	double d;
};

int main() {
	printf("sizeof(struct S1) = %d\n", sizeof(struct S1));
	printf("sizeof(struct S2) = %d\n", sizeof(struct S2));
	printf("sizeof(struct S3) = %d\n", sizeof(struct S3));
	printf("sizeof(struct S4) = %d\n", sizeof(struct S4));
	return 0;
}

运行结果如下：

• 内存对齐原因：

1. 平台原因(移植原因)：
   不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
   问。

例如整型指针一次访问4个字节，如果不进行内存对齐，S1 在内存中存放情况如下：
当想访问成员 i 时，第一次一次访问只能访问成员 i 的前三个字节，只有进行两次访问才能取得完整的 i

然而进行内存对齐后，在第二次访问中，一次访问就能访问 i 的全部内容

• 结构体的内存对齐是拿空间来换取时间的做法

修改内存对齐

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

运行结果如下：

---