结构体是c语言的一种自定义类型，自定义类型对于开发者及其重要的类型，它可以随意由开发者进行谱写功能，而今天的结构体可以用来表示一种变量的单个或多种具体属性，再编写代码时有着不可替代的作用！！！！

目录

前言：自定义类型

一、结构体类型的声明

1.1结构体的面貌

1.2结构体的定义 

1.3特殊的声名-----匿名结构体类型

1.4结构体的自引用

二、结构体的定义和引用

2.2 结构体内存对齐

---

---

前言：自定义类型

什么是自定义类型？我们在编写代码的过程中，会遇到许多类型，比如：短整型，整型，字符类型，布尔型，浮点型等多种类型，可这些都是c语言库中自带的，编写者在编写过程中只需要记住就好。

举个例子：你要定义一个变量为整数，就需要定义该变量为int型，写一个字符，就要定义一个char类型。定义时只需对应拿出即可，但是你要定义一个人的基本信息怎么办，如电话，地址，性别，名字，身份等多种属性，在c语言给出的类型中，并没有具体的类型可以去定义，所以这时就需要编写者自己根据具体的需求，去编写自己的类型，我们称为自定义类型.

而结构体类型就是常见的自定义类型的一种。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、结构体类型的声明

1.1结构体的面貌

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

例如我们要表示一个人，那么他的名字，电话号码，身份，性别，年龄就是他的成员变量，名字可以是字符型，电话可以是整型，身份，性别都可以是整型，就是这些成员变量构成了一个结构。

1.2结构体的定义 

struct tag

{

成员列表1.;

成员列表2.；

}列表变量;

struct 为结构的关键字，tag 则为这个结构的类型名 

为了更进一步了解，我们描述一位学生

struct su
{char name[20];//名字int age;//年龄char sex[];//性别
};

其中“；”（分号）是千万不能丢的。 

1.3特殊的声名-----匿名结构体类型

什么叫匿名结构体类型，顾名思义，就是结构体的类型是匿名的

struct 
{
    char name[20];//名字
    int age;//年龄
    char sex[];//性别
};

对比一下，少了“su”结构体类型，匿名结构体固然很帅，但是也是有很大的弊端的。

先对比两组代码

代码一：

struct 
{char name[20];//名字int age;//年龄char sex[];//性别
}li;

代码二：

struct 
{char name[20];//名字int age;//年龄char sex[];//性别
}*p;

我们在编译器上运行一下

我们会发现：

因为如果我们不写类型名，系统就不知道它们两个各自是什么类型

注意：指针是指向同类型的变量的，而这两个结构没有明确的类型。所以系统不认为他们是同一类型的结构，所以会报错。

就像一个字符指针无法接收一个整型变量。匿名结构体也是一样的，所以是非法的。

1.4结构体的自引用、

在内存中有可能是连续存放的，也有可能是像这样不连续存放的，随机存放的。

这样的1，2，3，4，5的数字我们称作节点，在节点里除了存放数据外，还有可能存放下一个节点的信息，我们将一个节点看作一个结构体，那么，结构体可以自己找到自己吗？

自引用类型：Node；

所以我们可以写出自引用代码

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

为什么这个不行哪？？？

仔细分析，其实本来就不行，结构体引用了同类型的结构体，结构体的大小会变的无限大，最终可能会导致内存崩溃。

但是如果不能自引用，那么为什么还要说明自引用哪？

所以是有正确的自引用方式的

我们在每个节点存放下一个节点的信息，在一个节点处存放下一个节点的地址，因此可以在结构体中存放一个结构体指针类型，这样既能解决同类型的问题不会导致无限大，还能找到下一个结构体节点的信息。

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

 这次我们发现，编译器不再报错。。。

问题：在结构体⾃引⽤使⽤的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易引⼊问题，看看 下⾯的代码，可⾏吗？

解答：这段代码其实是错误的，他将Node的重命名定义在了使用Node的后面，这样会导致系统无法正常识别Node是什么，所以程序错误。

二、结构体的定义和引用

初始化方式：

1.最标准的定义：

 struct su
{char name[20];//名字int age;//年龄char sex[];//性别
};int main(){struct su  a = { "qingkai",18,"n"};//初始化printf("名字%s\n年龄%d\n性别%c\n", a.name, a.age, a.sex);//引用return 0;}

2.最不环保的方式：

#include <stdio.h>
struct student /*声明时直接定义*/
{
int age;  /*年龄*/
float score;  /*分数*/
char sex;   /*性别*/
/*这种方式不环保，只能用一次*/
} a={21,80,'n'};
int main ()
{printf("年龄：%d 分数：%.2f 性别：%c\n", a.age, a.score, a.sex );
return 0;
}

3.最烂的方式

2. 

struct   //直接定义结构体变量，没有结构体类型名。这种方式最烂
{
int age;
float score;
char sex;
} t={21,79,'f'};
int main ()
{
printf("年龄：%d 分数：%f 性别：%c\n", t.age, t.score, t.sex);
return 0;
}

2.1.2引用的方式 ：

2.1.1.1"操作符引用

"."操作符引用：结构体变量.成员列表

如a.name，a.age，a.sex；

这种直接使用成员列表。

2.2.2.2"->"操作符引用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
struct book
{char book_name[20];//书名char author[20];//作者char id[20];//编号float price;//价格
};
int main()
{struct book s1 = { "c语言","谭浩强","THQ3324",55.5f };struct book s2 = { .author = "谭浩强",.book_name = "c语言",.id = "THQ3324",55.5f };//.引用struct book* ps = &s2;printf("%s %s %s %f\n", s1.author, s1.book_name, s1.id, s1.price);printf("%s %s %s %f\n", ps->author, ps->book_name, ps->id, ps->price);//->引用return 0;
}

我们可以看出：

我们看到这两种引用方式的结果一模一样，区别是箭头引用只能是指针变量使用。2.

2.2 结构体内存对齐

内存是什么？？？，为什么会有内存对齐？？？

我们都知道一个整型占4个字节，一个字符类型占1个字节，而占的字节数，就是所需内存

。但是一个结构体因为定义的类型各有不同，那么结构体占多少内存哪？？

别急，我们对比代码

代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
struct book1
{char book_name;//书名char author;//作者char id;//编号int price;//价格
};
struct book2
{char bok_na;char auy;int price;char id;
};
int main()
{printf("%d\n", sizeof(struct book1));printf("%d\n", sizeof(struct book2));return 0;
}

不妨先猜一猜：char类型有三个，占3个字节，int类型有一个，占4个字节，最后一定都是占4+3==7个字节吧！！！

运行代码：

？？？？，为什么哪，不要疑惑，不要惊讶，这就是内存对齐！！！！

2.2.1内存对齐

   对齐规则

• 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
•  其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。 
• 对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值

- VS 中默认的值为 8

- Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

•  结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的 整数倍。
• .如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构 体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

这里我们先介绍一种宏offsetof作用是计算结构体成员相较结构体变量起始位置的偏移量。

偏移量就是相较于起始位置的字节偏移量

偏移量 - C++ 参考 (cplusplus.com)

这里我们以struct book1类型结构体为例，

、

#include<stdio.h>
#include<stddef.h>//头文件struct book1
{char book_name;//书名char author;//作者char id;//编号int price;//价格
};
int main()
{printf("%d\n", offsetof(struct book1, book_name));printf("%d\n", offsetof(struct book1, author));printf("%d\n", offsetof(struct book1, id));printf("%d\n", offsetof(struct book1,price ));return 0;
}

运行代码：

接下来我们就一点一点深挖这结果的由来

1.无结构体嵌套

我们已经知道4个成员的偏移量分别是：0，1，2，4

由此我们可以画出

我们可以看出，正好8个字节，与程序运行的结果相同

 中间的画红×的字节就被舍弃了，舍弃的原因我们稍后讲解。 

2.代码2

struct s2
{char c1;int n;char c2;};int main()
{printf("%zd\n", offsetof(struct s2, c1));printf("%zd\n", offsetof(struct s2, c2));printf("%zd\n", offsetof(struct s2, n));return 0;
}

乍一看没什么不一样，我们运行结果试一试 

三个成员的偏移量为0，4，8

这里的字节最高字节数看着是9，但是还记得对齐规则吗？

 所以在以上struct s2中一开始第一个成员c1的大小为1，比vs默认偏移数8小，所以偏移数就是1，c1大小为1

第二个成员n的大小为4，比vs默认偏移数8小，所以偏移数就是4，所以n从第五个字节开始，n大小为4字节

第三个成员c2的大小为1，比vs默认偏移数8小，所以偏移数就是1，所以n从第九个字节开始，c2大小为1字节

在此还未结束，因为结构体总大小为最大对齐数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的整数倍，

该结构体struct s2最大对齐数为4，所以结构体大小必须是4的整数倍，

9字节并不是4的整数倍，所以struct s2大小为12字节 

 2.有结构体嵌套的内存对齐

#include<stdio.h>
struct S3
{double x;char c;int n;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{printf("%zd\n", sizeof(struct S4));return 0;}

•  如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍

所以对于嵌套结构体来说，在s4结构体中，s3的结构体成员要对齐到8的整数倍

s4的整体大小是所有最大对齐数的整数倍

• c1的大小为1个字节，偏移量为0
•  s3偏移量为8，大小为16字节
• d的大小为8个字节，偏移量为24

最终结构体struct S4大小就为32个字节 

2.2 为什么存在内存对齐

 1. 平台原因 (移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用⼀个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。

例如在以上结构体struct S中如果机器每次内存读取4个字节，在未对齐情况下就要读取两次，而在对齐的情况下就只要读取一次 

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起

2.3 修改默认对齐数

在以上的学习中我们知道了VS的默认对齐数是8，那么有什么办法可以修改默认对齐数呢？
其实是有办法的，利用#pragma 这个预处理指令，可以改变编译器的默认对齐数。

#include<stdio.h>
#pragma pake(1)//修改默认对齐数为2
struct s1
{char c1;char c2;int n;
};
#pragma pake()//恢复默认对齐数
int main()
{printf("%zd", sizeof(struct s1));return 0;
}

 使用了#pragma后默认对齐数就被修改为了2，结构体struct s1的大小就变成6字节

结构体传参

#define _CRT_SECURE_NO_WARNINGS 1#include<stdio.h>
struct S
{int data[1000];int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体传参
void print1(struct S s)
{for (int i = 0; i < 4; i++){printf("%d ", s.data[i]);}printf("\n");printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{for (int i = 0; i < 4; i++){printf("%d ", ps->data[i]);}printf("\n");printf("%d\n", ps->num);
}
int main()
{print1(s); //传结构体print2(&s); //传地址return 0;
}

 在函数传参的时候分为传值调用和传址调用，结构体中也有两种调用，如print1是传值调用，print2是传址调用。虽然两种方式都能找到结构体成员，但是对于系统来说，传值调用是很不利的，原因是使用传址调用不用再开辟一块内存空间，新创建的指针就指向了原来的那块内存空间，而使用传值调用时，需要再创建一块新的内存空间，如果这个结构体像以上struct S一样所占内存空间很大的话，再创建新的内存就很浪费内存，还有函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

结论：结构体传参最好用传址调用。