typedef是类型定义的意思，typedef struct是为了使用这个结构体方便。
 
在了解typedef之前我们先来了解一下什么是结构体类型：
 
C++提供了许多种基本的数据类型(如int、float、double、char等)供用户使用。但是由于程序需要处理的问题往往比较复杂，而且呈多样化，已有的数据类型显得不能满足使用要求。因此C++允许用户根据需要自己声明一些类型，用户可以自己声明的类型还有结构体类型(structure)、共用体类型(union)、枚举类型(enumeration)、类类型(class )等，这些统称为用户自定义类型(user-defined type,UDT)。
 
在一个组合项中包含若干个类型不同(当然也可以相同)的数据项。C和C++允许用户自己指定这样一种数据类型，它称为结构体。它相当于其他高级语言中的记录(record)。例如，可以通过下面的声明来建立数据类型。
 
struct Student//声明一个结构体类型Student
 
{
 
int num;//包括一个整型变量num
 
char name[20];//包括一个字符数组name，可以容纳20个字符
 
char sex;//包括一个字符变量sex
 
int age;//包括一个整型变量age
 
float score;//包括一个单精度型变量
 
char addr[30];//包括一个字符数组addr，可以容纳30个字符
 
};//最后有一个分号
 
有点类似于java中的类，结构体是用户自定义的类型，比如在java中我们可以用
 
class student{
 
private string name;
 
private string num;
 
...
 
}
 
还有一些函数，在c语言中结构体中只能是数据，但是对于C++和java这种面向对象的语言来说里面还可以有函数。
 
值得一提的是，前面只是指定了一种结构体类型，它相当于一个**模型**，但其中并无具体数据，系统也不为之分配实际的内存单元为了能在程序中使用结构体类型的数据，应当定义结构体类型的变量，并在其中存放具体的数据。
 
如上面我们已经定义了一个结构体类型Student，那么我们就可以用它来定义结构体变量，如：
 
struct Student stu1,stu2；
 
这说明现在stu1,stu2都是结构体类型了，里面所包含的内容就必须喝上面定义的Student结构体相照应。
 
当然也可以直接在声明的时候就定义两个结构体变量
 
```cpp
 
struct Student//声明结构体类型Student
 
{
 
int num;
 
char name[20];
 
char sex;
 
int age;
 
float score;
 
char addr[30];
 
}student1,student2;//定义两个结构体类型Student的变量student1,student2
 
关于结构体类型，有几点要说明：
 
(1) 不要误认为凡是结构体类型都有相同的结构。实际上，每一种结构体类型都有自己的结构，可以定义出许多种具体的结构体类型。
 
(2) 类型与变量是不同的概念，不要混淆。只能对结构体变量中的成员赋值，而不能对结构体类型赋值。在编译时，是不会为类型分配空间的，只为变量分配空间。
 
(3) 对结构体中的成员(即“域”)，可以单独使用，它的作用与地位相当于普通变量。
 
(4) 成员也可以是一个结构体变量。
 
(5) 结构体中的成员名可以与程序中的变量名相同,但二者没有关系
 
关于结构体里面的 变量
 
在定义了结构体变量以后，当然也可以引用这个变量
 
(1) 可以将一个结构体变量的值赋给另一个具有相同结构的结构体变量。
 
(2) 可以引用一个结构体变量中的一个成员的值。
 
如stu1.num=10010;
 
(3) 如果成员本身也是一个结构体类型,则要用若干个成员运算符,一级一级地找到最低一级的成员。
 
例如,对上面定义的结构体变量student1, 可以这样访问各成员:
 
student1.num (引用结构体变量student1中的num成员)
 
如果想引用student1变量中的birthday成员中的month成员，不能写成student1.month，
 
必须逐级引用，即
 
student1.birthday.month=12;
 
(引用结构体变量student1中的birthday成员中的month成员)
 
(4) 不能将一个结构体变量作为一个整体进行输入和输出。
 
例如,已定义student1和student2为结构体变量,并且它们已有值。不能企图这样输出结构体变量中的各成员的值:
 
cin>>student1;
 
只能对结构体变量中的各个成员分别进行输入和输出。
 
(5) 对结构体变量的成员可以像普通变量一样进行各种运算(根据其类型决定可以进行的运算种类)。
 
结构体数组
 
一个结构体变量中可以存放一组数据(如一个学生的学号、姓名、成绩等数据)。如果有10个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。结构体数组与以前介绍过的数值型数组的不同之处在于：
 
每个数组元素都是一个结构体类型的数据，它们都分别包括各个成员项
 
定义
 
定义结构体数组和定义结构体变量的方法相仿，定义结构体数组时只需声明其为数组即可。如
 
struct Student{
 
int num;
 
char name[20];
 
char sex;
 
int age;
 
float score;
 
char addr[30];
 
};
 
Student stu[3];//定义Student类型的数组stu
 
突然感觉自己的c语言白学了，这些也都是在百度找的东西，通俗的理解了一下，记录一下。

 
struct 、typedef以及结构体指针用法
 
typedef用法
 
结构体指针用法
 
结构体初始化
 
typedef是类型定义的意思。typedef struct 是为了使用这个结构体方便。具体区别在于:
 
若struct node{ }这样来定义结构体的话。在定义 node 的结构体变量时，需要这样写:struct node n;
 
若用typedef，可以这样写：typedef struct node{}NODE; 。在申请变量时就可以这样写：NODE n;其实就相当于 NODE 是node 的别名。区别就在于使用时，是否可以省去struct这个关键字。 有些时候，typedef struct NODE{ }NODE;还是可以直接NODE n；定义一个NODE类型的结构体。
 
typedef用法
 
用法举例1：在C中定义一个结构体类型时如果要用typedef:
 
typedef struct Student
 
{
 
int no;
 
char name[12];
 
}Stu,student;
 
于是在声明变量的时候就可：Stu stu1;或者：student stu2;(Stu 和student 同时为Student的别名)
 
用法举例2：如果没有typedef，传统定义一个结构体：
 
struct Student
 
{
 
int no;
 
char name[12];
 
}Stu;
 
此时说明已经定义了一个结构体Stu变量，如果要重新新建，就必须用struct Student stu1;
 
用法举例3：如果使用了typedef，另外这里也可以不写Student(于是也不能struct Student stu1;了)
 
typedef struct
 
{
 
int no;
 
char name[12];
 
}Stu;
 
用法举例4：typedef 还可以掩饰复合类型，如指针和数组。定义一个 typedef，每当要用到相同类型和大小的数组时，可以这样：
 
typedef char Line[81];
 
此时Line类型即代表了具有81个元素的字符数组，使用方法，例如Line text, secondline;
 
结构体指针用法
 
结构体指针用法1：
 
结构体要自引用时，Student1是错误用法。试想引用成员next是另一个完整的结构，其内部还将包含它自己的成员next,这第二个成员又包含一个完整的结构，它还将包括它自己的成员next，这样重复下去永无休止，内存都用光了。所以不合法。
 
struct Student1
 
{
 
int age;
 
struct Student1 next;
 
};
 
正确的用法是：结构体自引用 ，只能自引用指针。编译器在结构的长度确定之前就已经知道指针的长度，所以这种自引用是合法的。结构体的自引用在实现链表，树等高级的操作时用处很大。
 
struct Student1
 
{
 
int age;
 
struct Student *next;
 
};
 
结构体指针用法注意：这样是不行的，虽然Student1代表了结构体，但是Student1类型名的声明是在末尾定义，当要声明struct{ }时，内部无法识别Student1类型。
 
typedef struct
 
{
 
int age;
 
Student1 *next;
 
}Student1,*StudentPtr;
 
结构体指针用法2：
 
注意此时，Student1是struct Student{}的别名，StudentPtr是Student的指针
 
typedef struct Student1
 
{
 
int age;
 
Student1 *next;
 
}Student1,*StudentPtr;
 
我使用StudentPtr时出现了个有意思现象，结构体指针若不手动分分配内存，讲道理是不能用的。当定义了两个结构体指针s1,s2，两个结构体指针都不分配内存，给其中一个赋值，然后使用没有问题，输出良好。
 
#include 
 
typedef struct Student1
 
{
 
int age;
 
Student1 *next;
 
}Student1,*StudentPtr;
 
int main()
 
{
 
StudentPtr s1;
 
StudentPtr s2;
 
s1->age= 9;
 
printf("%d",s1->age);
 
return 0;
 
}
 
当尝试给另一个结构体指针赋值时，编译没有问题，程序运行奔溃。
 

 
 
 
正确用法应该是
 
结构体指针需要初始化
 
结构体指针的成员指针同样需要初始化
 
若直接使用结构体，结构体中有成员指针，成员指针也要先初始化
 

 
结构体初始化
 
结构的初始化方式和数组初始化很相似。一个位于一对花括号内部，由逗号分隔的初始值列表可用于结构的初始化。这些值根据结构成员列表的顺序写出。
 
 

转载：
 
https://www.cnblogs.com/FYXin/p/5794719.html
 
代码：
 
 
 
结构体的定义：
 
 
1.
 
 
　　 struct Person {
 
 
　　　　char name[20];
 
 
　　　　char sex;
 
 
　　　　float  height;
 
 
　　　　int age;
 
 
};   只有结构体的定义
 
 

 
 
2.　　
 
 
　　struct Person {
 
 
　　　　char name[20];
 
 
　　　　char sex;
 
 
　　　　float  height;
 
 
　　　　int age;
 
 
} xiaohong;  附加该结构体类型的“结构体变量”的初始化定义结构体
 
 
 
 
这种定义就相当于
 
 
　　struct Person {
 
 
　　　　char name[20];
 
 
　　　　char sex;
 
 
　　　　float  height;
 
 
　　　　int age;
 
 
};
 
 
　　struct Person  xiaohong； 
 
 
定义另一个结构体
 
 
　　struct Person xiaoming ; 定义一个变量名为xiaoming的结构体
 
 
 
 
这种每次都要加一个struct关键字的写法有点麻烦
 
 

 
 
3.
 
 
　　typedef struct Person {
 
 
　　　　char name[20];
 
 
　　　　char sex;
 
 
　　　　float  height;
 
 
　　　　int age;
 
 
}Per； 这种写法在声明结构体变量的时候就可以用 Per xiaoming；
 
 
　　　  如果没有typedef 就必须用 struct Person，这里的Per实际上就是 struct Person的别名
 
 
 
 
另外这里也可以不写Student（于是也不能struct Student stu1;了）
 
 
        typedef struct
         {
             int a;
         }Stu;
 
 

        但在c++里很简单，直接
         struct Student
         {
            int a;
         };
        于是就定义了结构体类型Student，声明变量时直接Student stu2；
        也就是说，C++里的struct本身已经含有typedef的部分功能了。
 

 
结构体
 
结构体的定义方式
结构体大小的计算
结构体间的赋值
结构体数组
结构体指针
位段
共用体
枚举类型

 
结构体的定义方式
 
//使用方式一
struct 结构体名
{
  int a;
  int b;
  char x;
}; //需要分号
struct 结构体名 变量名;
//使用方式二 声明与定义同时进行
struct 结构体名
{
   int a;
   int b;
}变量名;
//使用方式三  直接进行定义
struct 
{
  int a;
  int b;
}stu1;
//使用方法四   使用typedef 重新定义一个数据类型
typedef struct stu
{
  int a;
  int b;
}stu,*pstu; 
其中stu表示的是 struct stu 
    *pstu表示的是 struct stu *
使用方法   stu stu1; 等价于struct stu stu1
          pstu stu1; 等价于struct stu* stu1;
 
结构体大小的计算
 
//一、结构体成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）
 
//二、结构体大小必须是所有成员大小（数组,结构体除外）的整数倍
 //对齐方式浪费空间 但是效率提升 提升计算机对内存的效率
 指针的大小就是4字节
 
struct s2{
char ch1;//1   偏移3个数     1           0        
int i;//  4
char ch2; //1   
};
计算 得到的结构体大小是12 
数据类型的大小  偏移值
1                0
4                1+3
1                8
此时的结构体大小是 1+8等于9 不是最大的数类型的整数倍 因此最终是12
 
struct s1
{
   char c;//1                1         0
   char c1;//1               1         1
          //                 4         2+2               4+4等于8      
   int a;
};
结构体的大小是8 是4的整数倍
 
struct s3{
char ch;  //1     1      0
int i;  //8       4      1+3
char str[10];//   10      8   
};
当前的成员的大小是18 不是4的整数倍 因此该结构体的大小是20  当前的数组的大小是12字节
当该数组的大小是12的时候 大小是20 是4的整数倍   大小是20
当该数组的大小是14的时候 大小是22 不是4的整数倍 因此是24   当前的数组大小占用16个字节
 
struct s4{
		char ch;//1
		int i;  //4  3    //8个字节
        //结构体里面应该是多少字节就是多少字节  不会进行对齐和其他的结构体成员 最开始的是16   现在的是32字节 
        //如果下面的float没有  则是40 个字节		  
        int zz;  //4  
        int cc;  //4
		float f; //4    //20个字节   但是要满足里面的类型的大小的倍数     24 要满足最大是
        
        struct s//一共16个字节    32 
		{     
			char ch1;//1
			int j;//  4   3
            char ch2;
            int i;  
            double x;//
          double c;           
			double d;//8个字节  
        }stem;//如果结构体后面有东西表示的是一个结构体变量
}mm;
上面的是结构体中又嵌套了一个结构体  进行计算
结构体上面的大小是20个字节
嵌套的结构体stem大小是40个字节   
因此总共是60个字节 但是不是最大的数据类型double的8的倍数  因此最终大小是64
 
将上面的结构体进行改变
 
struct s4{
		char ch;//1
		int i;  //4  3    //8个字节
        //结构体里面应该是多少字节就是多少字节  不会进行对齐和其他的结构体成员 
        int zz;  //4  
        int cc;  //4
		float f; //4    //20个字节   但是要满足里面的类型的大小的倍数     24 要满足最大是
        double x;//              
        struct s//
		{     
			char ch1;//1
			int j;//  4   3
            char ch2;  
        }stem;//如果结构体后面有东西表示的是一个结构体变量
}mm;
除了stem结构体的大小是32
stem的结构体大小是12 
但是stem因为要适应double 8的倍数 因此stem的大小是16 
因此 该结构体大小是16+32  48
当删除上面的double类型的变量的时候
结构体的大小是32
 
struct s5{
	char ch; // 1
	int i;   //4   3   8
	union{//联合体 算的是里面最大的值   //4
	char ch1;
	int j;
	//double zz;  最大时8
	};
	char x; 1  
};
联合体算的是最大的值所占用的大小  里面最大的是int类型 因此是4个字节
13不是4的倍数 因此是16
因此大小是16个字节
添加上double 以后
为17 因为不是最大类型double的倍数
因此时24
 
#pragma pack(4)  //指定向4对齐 最大是8
              //如果不定义这个就是24个字节  因为最大的是8 也要是8的倍数
struct s6{
	char ch;  //1   0
	int i ;   //4   1+3  
	float f;  //4   8
	double d; //8   12  向4对齐   所以这个结构体的大小是20
};
最终的结果等于12+8 =20  因为指定向4对齐 因此结构体的大小是20
#pragma pack(10)//如果元素大小没有超过元素最大值  就按照里面最大的 进行对齐
                //成员里面没有超过10   所以按照最大值进行计算
                
/*
1     0
4     1+3
4     4+4
8     12         
*/
struct s7{
char ch;//1
int i;//  4  3   8
float f; //4    12
double d;  //8    20      24 变成d的倍数  
};
因为里面没有超过10的，因此按照里面的最大类型的字节数
最终计算得到的是20 不是8的倍数  因此要变成24
 
结构体间的赋值
 
相同类型的结构体之间可以直接进行赋值
 
struct stu
{
  int a;
  int b;
  char c[20];
};

int main()
{
  struct stu xiaoming ={111,22,"xiaoming"};
  struct stu lisi;
  //两者属于相同的结构体类型，可以直接进行赋值
  lisi=xiaoming;
  //执行printf lisi的输出的结果就是xiaoming上面的赋值的结果
}
 
结构体数组
 
定义方法
 
struct stu
{
  int a;
  int b;
  char c[20];
};

struct stu edu[3];//定义了一个struct stu类型的结构体数组edu
/* 该数组有三个元素edu[0] edu[1] edu[2] */

/*结构体数组元素的使用*/
结构体数组名[下标].成员
edu[0].a=11;
 
结构体指针
 
/*  结构体在使用的时候，需要进行开辟内存空间 */
struct stu *zhangsan=NULL;
/*  结构体进行开辟内存空间后才能进行赋值 */
zhangsan = (struct stu*)malloc(sizeof(struct stu));
 
位段
 
在结构体中以位为单位的结构体成员，称之为位段 或者位域

注意: 不能对位域元素取地址

struct data
{
/* 16 位表示的是2个字节*/
 unsigned int a:2; /* :后面添加位数*/
 unsigned int b:6;
 unsigned int c:4;
 unsigned int d:4;
 unsigned int i; /*什么都没有添加表示以字节为位*/
};

对于位段进行赋值时，不能超过位段的最大值
例如 位数时2  则最大值时2的二次方-1   3

位段的类型必须是整型或者字符型
位段不能跨单元进行存储

位段的长度不能超过储存单元的长度
例如:char最大的储存单元是8 因此不能超过8
int 最大储存单元是32       因此不能超过32

struct stu
{
/* 由于使用了长度0的位段，其作用是让下一个位段在下一个存储单元进行存储*/
 unsigned char a:3;
 unsigned char b:4;
 unsigned char c:0;
 
 unsigned char d:3;  //在下一个单元进行存取
 
};

 
共用体
 
共用体 只需要把struct 转换成 union 就可以进行使用

共用体：在进行某种算法的时候，需要使用几种不同类型的变量存放在同一内存中，几个变量使用的内存相互重叠。
这种几种不同的变量占用同一内存空间的结构，在C语言中，被称为共用体

使用最大的字节数作为共用体的大小

共用体的特点
1）使用共用体变量的目的是希望用同一个内存段存放几种不同类型的数据，但请注意，在每一个瞬间只能存放其中一种，而不是同时存放几种；
2）能够访问的是共用体变量中最后一次被赋值的成员，在对一个新的成员赋值后原有的成员就失去作用。(覆盖)
3）共用体变量的地址和它各成员的地址都是同一个地址；
4）不能对共用体变量名赋值；不能企图引用变量名来得到一个值；不能在定义共用体变量时对它初始化；不能用共用体变量名作为函数参数。
5）和第二条相同 上一次初始化赋值，会被下一次的初始化所代替

 
#include <stdio.h>
#include <stdlib.h>
union stu
{
 int a;
 int b;
 char x;
};
int main()
{
	union stu xiaoming;
    xiaoming.a=100;
    xiaoming.b=120;
    xiaoming.x=62;
    printf("%d %d %d\n",xiaoming.a,xiaoming.b,xiaoming.x);
	system("pause");
	return 0;
}

 
 
枚举类型
 
枚举元素是一个常量
 
将变量的值一一的列举出来，变量的值只限于列出来的值的范围之内

1.枚举类型的定义方式
enum 枚举类型名{
  枚举值列表
};
枚举值表中应该列出所有可用值，也成为枚举元素

枚举变量只能取值 枚举值列表的值

2.枚举变量的使用
//加密类型
/* 使用的esp8266在stm32的程序中的*/
typedef enum{
	Multiple_ID_0 = 0,
	Multiple_ID_1 = 1,
	Multiple_ID_2 = 2,
	Multiple_ID_3 = 3,
	Multiple_ID_4 = 4,
	Single_ID_0 = 5,
} ENUM_ID_NO_TypeDef;

ENUM_AP_PsdMode_TypeDef enunPsdMode=Single_ID_0;//进行赋值使用

/* 最开始没有进行赋值 会默认是0  依次类推 */
typedef enum{
  STA,
  AP,
  STA_AP  
} ENUM_Net_ModeTypeDef;

/* 这样的执行结果是xx=4 yy=5 zz=4 qq=5*/
enum stu{
ss=3,xx,yy,zz=4,qq
};
/* */