定义结构体变量以后，下一步可以引用了。
好比记到脑子里的知识，可以开始输出了，输出倒逼输入…
老大说了，不能把结构体变量整体输入或输出，只能对每个具体成员进行输入/输出操作。
struct wolf
{
	char name;
	int number;
	int score;
}zhang3,wang5;

上一节（上面）的例子来讲，
错误示范：
printf("%s %d %d",zhang3);

但是相同类型的结构体变量可整体赋值，比如可张3的成绩利用乾坤大挪移整到王5的头上冒名顶替。
wang5=zhang3

会按照对应的成员（姓名、学号、分数）一对一复制过去。
如何访问结构体成员呢？
一、成员运算符（又名圆点运算符）
eg.    (.)
访问形式：
结构体变量名**.**成员名
提出zhang3的分数
eg. zhang3.score=99;//分数是int整型变量，可以给他赋值
二、指向运算符（又名箭头运算符）
eg. （->）
访问形式：
指向结构体的指针变量名->成员名
提取wang5的分数
eg.
struct wolf *pt,wang5;
pt=&wang5;
pt->score=100;

最后提一点，这里的小数点不要忘记了，不能省。



拖延症的本质不是状态不好，而是没有目标。

一、概述
1.1 背景
需要将不同类型的数据组合成一个有机的整体（类似于JAVA中的类）
1.2 一般形式
struct 结构名{
	成员表列
};

1.3 剖析成员表列

成员表列由若干个成员组成，每个成员都是该结构的一个组成部分。对每个成员也必须做类型说明
形式为 类型说明符 成员名 如：int num等

1.4 基本结构体
struct student
{
	int numl;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30];
}

二、定义结构体的多种方法
2.1 先声明结构体，再定义变量名
struct student
{
	int numl;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30];
}
struct student student1,student2;

2.2 声明类型的同时定义变量
struct student
{
	int numl;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30];
}studet1,student2;

2.3 直接定义结构体类型变量
struct
{
	int numl;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30];
}studet1,student2;

2.4 结构中嵌套结构
struct date
{
	int month;
	int day;
	int year;	
};

struct
{
	int num;
	char name[20];
	char sex;
	struct date birthday;
	float score;
} boy1,boy2;

男生结构体中包含日期的结构体
三、结构体变量引用原则
3.1 原则一
正确引用结构体变量中成员的方式

引用方式：结构体变量名.成员名

//例如
student1.num = 100
//将学生1的学号赋值为100


“.”是成员（分量）运算符，它在所有的运算符中优先级最高
因此可以将student1.num作为一个整体来看待

案例
#include <stdio,h>
void main(){
	struct student{
		int num;
		char *name;
		char sex;
		float score;
}boy1,boy2;
boy1.num =001;
boy1.name = "tom";
printf("请输入一个性别和成绩");
scanf("%c %f"，&boy1.sex,&boy1.score);
boy2 = boy1;			//将boy1的全体成员赋值给boy2
printf("Number=%d\n  Name=%s\n",boy2.num,boy2.name);
printf("Sex =%c\n Score=%f\n",boy2.sex,boy1.score);
}

3.2 原则二
 如果成员本身又属于一个结构体类型，则要用若干个成员运算符，一级一级地找到最低一级的成员。只能对最低级的成员进行赋值或存取以及运算
案例
struct date
{
	int month;
	int day;
	int year;	
};

struct
{
	int num;
	char name[20];
	char sex;
	struct date birthday;
	float score;
} boy1,boy2;

对上面的成员变量，如果我们想要访问boy1的出生的年份，月份或者日子

boy1.birthday.year
boy1.birthday.month
boy1.birthday.day

3.3 原则三
对于结构体变量的成员可以像普通变量一样进行各种运算
案例
student2.score= student1.score;
sum = student1.score+student2.score;
student1.age++;
++student2.age; 

3.4 原则四
可以引用结构体变量成员的地址，也可以引用结构体变量的地址
结构体变量的地址主要用作函数参数，传递结构体变量的地址
案例
#include <stdio.h>
void main(){
	struct student
	{
		int num;
		char *name;
		char sex;
		float score;
	}boy1;
	
	boy1.num = 007;
	boy1.name = "Jane";
	printf("结构体的地址为：%o",&boy1);
	printf("学号的地址为：%o",&boy1.num);
	//结果是一样的
}

四、结构体数组
4.1 概述


一个结构体变量中可以存放一组数据（如一个学生的学号，姓名，成绩等数据）


如果有10个学生的数据需要参加运算，显然应该用数组，即为结构体数组


结构体数组中每一个数组元素都是一个结构体类型的数据，他们包括各个成员（分量）项


可以理解为JAVA中一个类 生成了多个对象，将多个对象放到数组中。我们可以根据这个数组的索引获得每一个对象，以及每个对象的属性


4.2 定义
只需要说明一个变量为数组即可

声明

方式一
struct student
{
	int num;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30]
};
struct student student[3];

方式二
struct student
{
	int num;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30]
} student[3];


初始化


struct student
{
	int num;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30]
} stu[2] = {
	{1,"zhangsan",'M',18,87,"beijing"},
	{2,"lisi",'F',19,84,"beijing"}
}

五、指向结构体类型数据的指针
5.1 概述

一个结构体变量的指针就是该结构体变量所占据的内存段的起始地址。
可以设置一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址
也可以指向结构体中的元素

5.2 一般形式
struct 结构名 *结构指针变量名

例如
struct stu *pstu;
//stu表示结构 pstu表示指针名称 *pstu表示指针

5.3 注意形式

结构指针变量必须先赋值后才能使用
赋值是把结构变量的首地址赋予该指针变量，不能把结构名赋予该指针变量

例如
struct student *pstu;
struct student
{
	int num;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30]
} boy;

pstu =&boy;//正确的     pstu=&student错误表示


因为结构名和结构变量是两个不同的概念。
结构名只能表示一个结构的形式，不会分配内存。
只有当某变量被说明为这种类型的结构时，才对该变量分配存储地址
因此&student是错误的，不可取一个结构名的首地址。

5.4 访问的一般形式
(*结构指针变量).成员名

 结构指针变量->成员名

 例如：
 (*pstu).num  //学生的学号
 	pstu->num  //学生的学号

#include <stdio.h>
struct stu{
	int num;
	char *name;
	char sex;
	float score;
}boy1 = {101,"yujunwen",'M',60}


void main(){
	struct stu *pstu;
	pstu=&boy1;
	printf("学号为%d 姓名为%s",boy1.num，boy1.name);

	printf("学号为%d 姓名为%s",(*pstu).num，(*pstu).name);

	printf("学号为%d 姓名为%s",pstu->num，pstu->name);
}

六、结构体指针变量作为函数参数
将一个结构体变量的值传递给另一个函数，主要形式：

用结构体变量的成员作参数
用结构体变量作实参
用指向结构体变量（或数组）的指针作实参，将结构体变量（或数组）的地址穿给形参

案例一：（先用结构体变量作函数参数）
#include <stdio.h>
#include <string.h>
struct student{
	int num;
	char name[20];
	float score[3];
};
void print(struct student)
void main(){
	struct student stu;
	
	stu.num = 8;
	//下面的yujunwen出现在常量区，对应上面的char name[20]出现在栈中
	strpy(stu.name,"yujunwen");
	//stu.name ="yujunwen";
	//如果使用上面注释中的方式，需要改为char *name.将常量区的yujunwen的地址交给name 指针
	stu.score[0] = 98.5;
	stu.score[1] = 99.0;
	stu.score[2] = 99.5;
	print(stu); 
}
void printf(struct student stu){
printf("学号为%d",stu.num);
printf("姓名为%d",stu.name);
printf("语文为%d",stu.score[0]);
printf("数学为%d",stu.score[1]);
}

案例二：（改用指向结构体变量的指针作实参）
#include <stdio.h>
#include <string.h>
struct student{
	int num;
	char name[20];
	float score[3];
};

void print(struct student *)；
void main(){
	struct student stu;
		
	stu.num = 8;
	strpy(stu.name,"yujunwen");
	stu.score[0] = 98.5;
	stu.score[1] = 99.0;
	stu.score[2] = 99.5;
	print(&stu); 
}
void printf(struct student *p){
printf("学号为%d",p->num);
printf("姓名为%d",p->name);
printf("语文为%d",p->score[0]);
printf("数学为%d",p->score[1]);
}

七、动态存储分配
7.1 概述

数组的声明必须是事先声明好的，即int a [10]，如果我们定义int a[n]则会进行报错。因为数组的长度不能进行动态的分配
常用的内存管理函数有以下三个

分配内存空间函数：malloc()函数，calloc()函数
释放内存空间函数free()函数



7.2 malloc()函数


函数原型： void *malloc(unsigned int size);


作用：是在内存的动态存储区分配一个长度为size的连续空间（size是一个无符号数）


返回值：是一个指向分配域起始地址的指针（类型为void）


如果此函数未能执行成功，则返回空指针null


7.3 calloc()函数


函数原型： void *calloc(unsigned n,unsigned size);


作用：在内存的动态存储区中分配n个长度为size的连续空间


返回值：是一个指向分配域起始地址的指针（类型为void）


如果此函数未能执行成功，则返回空指针null


7.4 free()函数


函数原型： void free(void *p);


作用：释放由p指向的内存区，使这部分内存区能被其他变量使用


返回值：无返回值


p是资金一次调用calloc或malloc函数时返回的值


八、用typedef定义类型
8.1 概述

用typedef声明新的类型名来代替已有的类型名

8.2 声明类型

声明INTEGER为整型

 typedef int INTEGER


声明结构类型

typedef struct{
	int month;
	int day;
	int year;
}DATE;
void main(){
	DATE date_one;
	date_one.month = 12;
	date_one,day = 21;
	date_one.year = 2020;
}


声明NUM为整型数组类型

typedef int NUM[100];


声明STRING为字符指针类型

typedef  char* STRING;

void main(){
	STRING string;
	string ="l am your father";
	printf("%s",string)
} 


声明POINTER为指向函数的指针类型，该函数返回整型值

typedef int (*POINTER)();

typedef void (*P)();
void main(){
	p p1;	//void (*p1）();
	p1 = fun;
	(p1)();
}
void fun(){
printf("%s",string)
}

8.3 说明


用typedef可以声明各种类型名，但不能用来定义变量


用typedef只是对已经存在的类型增加一个类型名，并没有创造新的类型


当不同的源文件中用到同一类型数据时，常用typedef声明一些数据类型，把他们单独放在一个文件中，然后再需要用到他们的文件中用#include命令，把他们包含起来


使用typedef有利于程序的通用与移植

结构体变量的定义

结构体就是将不同类型的数据组合成一个有机的整体，以便于引用。如定义一个学生的信息：

struct student{int num;char name[20];int score;};struct为结构体关键字，student就是这结构体的类型名，而 num，name, score就是该结构体的成员，他们可以是不同类型的，注意在定义类型的时候不要对结构体成员num，name, score赋初值。其次就是在大括号后面要有分号“；”。

定义结构体变量的方式

定义变量的方式都是大同小异的，都为数据类型+变量名这样一种方式，比如int型，首先得有int这样一个数据类型，然后再用int这个数据类型去定义一个变量，同样的，我们要定义一个结构体变量，必须要有一个结构体类型，然后用这个类型去定义一个变量。结构体变量的定义有多种方式：

方式一：先定义结构体类型再定义变量名



其中struct是关键字，student是结构体标记（用于为结构体命名），struct student代表该结构体的类型， 大括弧里面就是结构体的成员。注意大括弧的后面一定要有一个分号‘；’。到此为止我们有了"struct student"这样的类型了，struct student就等价于我们的int一样，接下来我们就要定义一个这样类型的变量，定义格式如下：struct student zhangsan; 这个zhangsan就是我们所要的结构体变量。

方式二：在声明类型的同时定义变量

如：



这种方式定义结构体，后续可以根据需要定义新的变量，如struct student Wangwu。 注意：不能用Zhangsan去定义新的变量，这里Zhangsan、Lisi都为变量名而不是结构体类型。

方式三：直接定义结构体类型变量



这种定义方式中结构体变量只能在定义结构体类型的时候定义，不能再定义其他的变量。这样的定义的结构体类型是没有名字的，我们也可以用typedef重新为这样的结构体类型命，如：



使用typedef后，我们可以用Zhangsan作为数据类型来定义新的变量。需要注意的是，不能直接使用Zhangsan.num，因为Zhangsan不是变量，而是结构体类型。

结构体变量的初始化：



结构体变量的应用：

结构体中的成员，可以像普通变量那样单独使用，如下面例子中，结构体变量A中的成员num，可以用A.num的方式来使用。

结构体变量的成员引用：结构体变量名.成员名



关于结构体的一点说明：

1、不能将结构体变量作为整体进行操作:printf("%d, %d\n", A);错误scanf("%d, ％d\n”,＆A)； //错误printf("%d, %d\n”, A.num, A.score); //正确scanf("%d, %d\n”, &Lucy.num, &Lucy.sex); //正确2、当结构体变量的成员也是结构体类型时，引用必须用最底层的成员变量，如下



3、成员名可与程序中的变量名相同,二者代表不同对象



4、可以引用结构体变量成员的地址，也可以引用结构体变量的地址,例如：scanf("%d", &A.num); //输入A.num的值printf("%d", ＆A）; //输出Bob的首地址目的：主要用作函数参数，传递结构体变量的地址。5、允许具有相同类型的结构变量可以相互赋值，其它情况不允许对结构变量直接赋值。



typedef

为自定义数据类型（结构体、共用体和枚举类型）定义简洁的类型名称

以结构体为例，下面我们定义一个名为 Point 的结构体：

struct Point
	
{
	
double x;
	
double y;
	
double z;
	
};
在调用这个结构体时，我们必须像下面的代码这样来调用这个结构体：

struct Point oPoint1={100，100，0};
	
struct Point oPoint2;
在这里，结构体 struct Point 为新的数据类型，在定义变量的时候均要向上面的调用方法一样有保留字 struct，而不能像 int 和 double 那样直接使用 Point 来定义变量。现在，我们利用 typedef 定义这个结构体，如下面的代码所示：

typedef struct tagPoint
	
{
	
double x;
	
double y;
	
double z;
	
} Point;
在上面的代码中，实际上完成了两个操作：

1、定义了一个新的结构类型，代码如下所示：

struct tagPoint
	
{
	
double x;
	
double y;
	
double z;
	
} ;
其中，struct 关键字和 tagPoint 一起构成了这个结构类型，无论是否存在 typedef 关键字，这个结构都存在。


2、使用 typedef 为这个新的结构起了一个别名，叫 Point，即：

typedef struct tagPoint Point
因此，现在你就可以像 int 和 double 那样直接使用 Point 定义变量，如下面的代码所示：

Point oPoint1={100，100，0};
	
Point oPoint2;
为了加深对 typedef 的理解，我们再来看一个结构体例子，如下面的代码所示：

typedef struct tagNode
	
{
	
char *pItem;
	
pNode pNext;
	
} *pNode;
从表面上看，上面的示例代码与前面的定义方法相同，所以应该没有什么问题。但是编译器却报了一个错误，为什么呢？莫非 C 语言不允许在结构中包含指向它自己的指针？


其实问题并非在于 struct 定义的本身，大家应该都知道，C 语言是允许在结构中包含指向它自己的指针的，我们可以在建立链表等数据结构的实现上看到很多这类例子。那问题在哪里呢？其实，根本问题还是在于 typedef 的应用。


在上面的代码中，新结构建立的过程中遇到了 pNext 声明，其类型是 pNode。这里要特别注意的是，pNode 表示的是该结构体的新别名。于是问题出现了，在结构体类型本身还没有建立完成的时候，编译器根本就不认识 pNode，因为这个结构体类型的新别名还不存在，所以自然就会报错。因此，我们要做一些适当的调整，比如将结构体中的 pNext 声明修改成如下方式：

typedef struct tagNode
	
{
	
char *pItem;
	
struct tagNode *pNext;
	
} *pNode;
或者将 struct 与 typedef 分开定义，如下面的代码所示：

typedef struct tagNode *pNode;
	
struct tagNode
	
{
	
char *pItem;
	
pNode pNext;
	
};
在上面的代码中，我们同样使用 typedef 给一个还未完全声明的类型 tagNode 起了一个新别名。不过，虽然 C 语言编译器完全支持这种做法，但不推荐这样做。建议还是使用如下规范定义方法：

struct tagNode
	
{
	
char *pItem;
	
struct tagNode *pNext;
	
};
	
typedef struct tagNode *pNod
结构体长度大小。

计算方法：

运算符sizeof可以计算出给定类型的大小，对于32位系统来说，sizeof(char) = 1; sizeof(int) = 4。基本数据类型的大小很好计算，我们来看一下如何计算构造数据类型的大小。

　　C语言中的构造数据类型有三种：数组、结构体和共用体。

　　数组是相同类型的元素的集合，只要会计算单个元素的大小，整个数组所占空间等于基础元素大小乘上元素的个数。

　　结构体中的成员可以是不同的数据类型，成员按照定义时的顺序依次存储在连续的内存空间。和数组不一样的是，结构体的大小不是所有成员大小简单的相加，需要考虑到系统在存储结构体变量时的地址对齐问题。看下面这样的一个结构体：

　　struct stu1

　　{

　　int i;

　　char c;

　　int j;

　　}；

　　先介绍一个相关的概念——偏移量。偏移量指的是结构体变量中成员的地址和结构体变量地址的差。结构体大小等于最后一个成员的偏移量加上最后一个成员的大小。显然，结构体变量中第一个成员的地址就是结构体变量的首地址。因此，第一个成员i的偏移量为0。第二个成员c的偏移量是第一个成员的偏移量加上第一个成员的大小（0+4）,其值为4；第三个成员j的偏移量是第二个成员的偏移量加上第二个成员的大小（4+1）,其值为5。

　　实际上，由于存储变量时地址对齐（现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那 么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。）的要求，编译器在编译程序时会遵循两条原则：一、结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍） 二、结构体大小必须是所有成员大小的整数倍。

　　对照第一条，上面的例子中前两个成员的偏移量都满足要求，但第三个成员的偏移量为5，并不是自身(int)大小的整数倍。编译器在处理时会在第二个成员后面补上3个空字节，使得第三个成员的偏移量变成8。

　　对照第二条，结构体大小等于最后一个成员的偏移量加上其大小，上面的例子中计算出来的大小为12，满足要求。

　　再看一个满足第一条，不满足第二条的情况

　　struct stu2

　　{

　　int k;

　　short t;

　　}；

　　成员k的偏移量为0；成员t的偏移量为4，都不需要调整。但计算出来的大小为6，显然不是成员k大小的整数倍。因此，编译器会在成员t后面补上2个字节，使得结构体的大小变成8从而满足第二个要求。由此可见，大家在定义结构体类型时需要考虑到字节对齐的情况，不同的顺序会影响到结构体的大小。对比下面两种定义顺序

　　struct stu3

　　{

　　char c1;

　　int i;

　　char c2;

　　}

　　struct stu4

　　{

　　char c1;

　　char c2;

　　int i;

　　}

　　虽然结构体stu3和stu4中成员都一样，但sizeof(struct stu3)的值为12而sizeof(struct stu4)的值为8。

　　如果结构体中的成员又是另外一种结构体类型时应该怎么计算呢？只需把其展开即可。但有一点需要注意，展开后的结构体的第一个成员的偏移量应当是被展开的结构体中最大的成员的整数倍。看下面的例子：

　　struct stu5

　　{

　　short i;

　　struct

　　{

　　char c;

　　int j;

　　} ss;

　　int k;

　　}

　　结构体stu5的成员ss.c的偏移量应该是4，而不是2。整个结构体大小应该是16。

结构体：描述结构的组织形式，不分配内存

结构体变量定义：先定义结构体类型，再定义结构体变量

结构体变量的定义主要有3种形式

结构体类型与结构体变量概念的区别：

（1）类型：不分配内存

变量：分配内存

（2）类型：不能赋值、存取、运算

变量：可以进行赋值、存取、运算

（3）结构体可以嵌套

（4）结构体成员名与程序中变量名相同，不会混淆

结构体变量的引用：

（1）不能对结构体变量整体赋值或输出，只能分别对各个成员进行引用。例如：cin>>student1;student1.num=100是正确的；cin>.student1.num;是错误的

可以将一个结构体变量整体赋给另外一个相同类型的结构体变量。例如：student2=student1;

（2）嵌套的结构体变量必须逐层引用。例如：student.birthday.day=25;

（3）结构体变量中的成员可以同一般变量一样运算。例如：student1.birthday.day++;student1.score+=60;

结构体变量的引用规则：

（1）引用方式：结构体变量名.成员名（“.”是成员（分量）运算符，优先级:1，结合性：从左到右）

（2）可以将一个结构体变量赋值给另一个结构体变量

（3）结构体嵌套时逐级引用

结构体变量的初始化有3种类型

结构体变量的使用：

（1）同类型的结构体变量之间可以相互直接赋值。

（2）结构体变量不能直接进行输入输出，它的每一个成员能否直接进行输入输出，取决于其成员类型，弱视基本类型或是字符数组，则可以直接输入输出。

（3）结构体变量可以作为函数的参数，函数也可以返回结构体的值。

结构体数组的定义有2种类型，结构体数组的初始化也有2种类型

指针与内存动态分配：通过使用new和delete单目运算符来实现动态变量的分配与撤销

（1）动态申请内存操作符new

使用格式：

new <类型名>  //动态变量

new <类型名> (<初值>)  //动态变量

new <类型名>[<元素个数>]  //动态数组

功能：生成一个（或一批）所给类型的无名动态变量

（2）释放内存操作符delete

使用格式：

delete<指针>

delete [  ] <指针>

功能：释放通过new生成的动态变量（或动态数组），但指针变量仍存在。