c语言基础学习09_复合类型

=============================================================================
涉及到的知识点有：
一、结构体
1、定义结构体struct和初始化、2、访问结构体中的成员、3、结构体的内存对齐模式、4、结构体中元素的位字段、
5、结构体中的数组、6、结构体的嵌套、7、结构体的赋值、8、通过指针访问结构体成员(即指向结构体的指针)、
9、通过指针访问结构体数组(即指向结构体数组的指针)、10、结构体变量的指针成员与浅拷贝、深拷贝的操作(即结构中的数组成员和指针成员)。
二、联合体
三、枚举类型
1、c语言中枚举的定义、2、改变枚举的默认值。
四、typedef
课堂练习：在堆中处理结构体的指针成员。
=============================================================================
=============================================================================
　　之前学过的数据类型叫做基本数据类型，也叫做单一数据类型。
　　例如：整型、浮点型、指针类型。

　　结构体、联合体、枚举类型、typedef叫做符合类型。

一、结构体

1、定义结构体struct和初始化
--------------------------------------
01、定义结构体struct不初始化

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 int main()
 {
     auto struct student st;    //定义了一个student类型的结构体变量，名字叫st。不初始化成员变量的值。
     //st.name = "刘德华";    //不能这么写，因为name是一个数组名，是一个数组变量，而"刘德华"是常量。
     strcpy(st.name, "刘德华");
     st.age = ;
     printf("name = %s, age = %d\n", st.name, st.age);    //name = 刘德华, age = 20

     return ;
 }

-----------------------------------------------------------------------------

02、定义结构体struct并初始化

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 int main01()
 {
     auto struct student st = { "周星驰",  };    //定义了一个student类型的结构体变量，名字叫st。并同时初始化成员变量的值。
     printf("name = %s, age = %d\n", st.name, st.age);    //name = 周星驰, age = 40

     return ;
 }

 int main02()
 {
     auto struct student st = { "周杰伦" };    //定义了一个student类型的结构体变量，名字叫st。并同时初始化成员变量的值。
     printf("name = %s, age = %d\n", st.name, st.age);    //name = 周杰伦, age = 0

     return ;
 }

 int main03()
 {
     auto struct student st = {  };    //定义了一个student类型的结构体变量，名字叫st。并同时初始化成员变量的值。
     printf("name = %s, age = %d\n", st.name, st.age);    //name = , age = 0

     return ;
 }

 int main()
 {
     auto struct student st = { .age = , .name = "张学友" };    //定义了一个student类型的结构体变量，名字叫st。并同时初始化成员变量的值。
     printf("name = %s, age = %d\n", st.name, st.age);    //name = 张学友, age = 30

     return ;
 }

=============================================================================
2、访问结构体中的成员

　　. 点操作符
=============================================================================
3、结构体的内存对齐模式

　　编译器在编译一个结构的时候采用内存对齐模式。
　　结构体总是以最大的成员变量作为对齐单位。（即一个结构体变量的成员总是以最大的那个元素作为对齐单位的。）

　　结构体对齐说明，如下图所示：

　　结构体成员出现的先后顺序不同，导致结构体会占用不同的内存，如下图所示：

　　如果结构体成员出现数组，那么是以数组的具体每个成员作为对齐标准。（即：不会以数组本身的大小作为对齐单位的。）

　　如果一个结构体中所有成员都是一种类型，那么这个结构体变量在内存中就基本和一个数组类似了。

　　结构体变量的地址就是这个结构体首元素的地址。
-----------------------------------------------------------------------------
vs2017下示例代码如下：

 #include <stdio.h>

 struct D
 {
     char a[];
     char b;
 };

 struct E
 {
     char a1;
     short a2;
     int a3;
 };

 //结构体对齐小规律：总是以2的倍数字节对齐的，因为计算机是二进制的，且c语言里面没有3个字节的数据。
 //1个字节，2个字节，4个字节，8个字节。1个字节可以等同于占用2个字节。
 struct F
 {
     char a1;
     short a2;
     int a3;
     short a4;
     char a5;
 };

 int main()
 {
     struct D d = {  };
     printf("%u\n", sizeof(d));    //

     char *s = (char *)&d;    //结构体D *类型和char *类型不兼容，需要强转。
     s[] = 'a';
     s[] = 'b';
     s[] = 'c';
     printf("%s%c\n", d.a, d.b);    //abc
     //由以上可知，所有的数据类型，都可以把它抽象成一个char的数组。包括结构体变量也不例外。
     //但是呢结构体变量本身也是个变量，所以不能直接把它当数组名来用，必须要取地址。
     printf("%p, %p, %p\n", &d, d.a, &s[]);    //00CFF9A4, 00CFF9A4, 00CFF9A4
     //结构体变量的地址就是这个结构体首元素的地址。

     //可以通过指针来利用被闲置的内存。
     struct E e = { , ,  };
     s = &e;
     s[] = ;
     printf("%p\n", &e);    //可以通过调试的方法看下内存。

     return ;    //在这一行加一个断点。
 }

结构体对齐小规律：总是以2的倍数字节对齐的。如下图所示：

=============================================================================
4、结构体中元素的位字段

定义一个结构体的时候可以指定具体元素的位长。

小知识补充：

一个字节的二进制表示的最大整数和最小整数是多少？
首先分清楚8个bit可以表示256种可能，但是表现为无符号的整数时是0到255，因为0到255共计256个数。

无符号位时：
　　无符号的正数的最大值：max = 1111 1111 = 2^8 - 1 = +255
　　无符号的正数的最小值：min = 0000 0000 = 2^0 = 1 = +0

有符号位时：
注意：在计算机内部，正数和负数都是以补码的方式存放的。又因为正数的补码是其本身，所以简言之：所有的负数都是以补码的方式存放的。
而打印的时候是以原码输出的。

　　有符号的正数的最大值：max = 0111 1111 = (2^8) / 2 - 1 = +127
　　有符号的负数的最小值：min = 1000 0000 = -128
　　-128到127共计256个数。
-----------------------------------------------------------------------------
vs2017下示例代码如下：

 #include <stdio.h>
 struct A
 {
     unsigned char a : ;    //a有2个bit大小。无符号：00~11            0~3
     unsigned char b : ;    //b有4个bit大小。无符号：0000~1111        0~15
     char c : ;                //c有4个bit大小，有符号：最高位是符号位    -8~7
     char d;                    //d有8个bit大小，有符号：最高位是符号位    -128~127
 };

 //结构体位字段的应用：霓虹灯管、音乐喷泉。每个小灯只有两种状态：亮或灭。
 //硬件特别差的情况下使用c语言写程序。
 struct B
 {
     unsigned char a1 : ;
     unsigned char a2 : ;
     unsigned char a3 : ;
     unsigned char a4 : ;
     unsigned char a5 : ;
     unsigned char a6 : ;
     unsigned char a7 : ;
     unsigned char a8 : ;
 };

 struct C
 {
     char a1 : ;
     int a2 : ;    //这样写是不合理的！
 };

 int main()
 {
     struct A a;
     a.a = ;
     printf("%x\n", a.a);    //101-->01-->1(无符号的16进制的1)
     a.b = ;
     printf("%x\n", a.b);    //1 0000-->0000-->0(无符号的16进制的0)
     a.c = ;    //
     printf("%d\n", a.c);    //1101-->最高位为符号位，-101-->-3(有符号的10进制-3)
     a.d = ;
     printf("%d\n", a.d);    //13(有符号的10进制13)

     struct B b;
     printf("%u\n", sizeof(b));    //
     b.a1 = ;
     b.a2 = ;
     b.a3 = ;
     b.a4 = ;
     b.a5 = ;
     b.a6 = ;
     b.a7 = ;
     b.a8 = ;

     struct C c;
     printf("%u\n", sizeof(c));    //8    因为是以int对齐的。

     return ;
 }

=============================================================================
5、结构体中的数组

　　结构体既可以定义变量，又可以定义数组！

　　对于cpu来讲，处理int的效率是最高的，但是int比char要多占内存而已。如下例子：
　　int i; 　　 //由于i < 100;按道理来讲，我们应该定义为char i;的，但是我们却不这样做，原因如上，且i是栈变量，只是在内存中呆一会就会消失的。
　　for(i = 0 ; i < 100; i++)
　　{

　　}
-----------------------------------------------------------------------------
vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     unsigned char age;
     int sex;
 };

 int main()
 {
     struct student st[];    //这句话的意思是：定义一个结构体数组，有3个成员，每个成员类型都是struct student的。
     //可以通过strcpy来进行赋值。
     //strcpy(st[0].name, "刘德华");

     //也可以使用手动输入赋值。
     //scanf("%s", &st[0].name);    //等价于scanf("%s", st[0].name);
     //scanf("%d", &st[0].age);
     //scanf("%d", &st[0].sex);
     //printf("%s, %d, %d\n", st[0].name, st[0].age, st[0].sex);

     //用循环给每个结构体数组成员赋值
     int i;
     for (i = ; i < ; i++)
     {
         printf("please input name ");
         scanf("%s", st[i].name);    //等价于scanf("%s", &st[0].name);
         printf("please input age ");
         scanf("%d", &st[i].age);
         printf("please input sex ");
         scanf("%d", &st[i].sex);
     }

     for (i = ; i < ; i++)
     {
         if (st[i].sex == )
         {
             printf("%s, %d, 男\n", st[i].name, st[i].age);
         }
         else
         {
             printf("%s, %d, 女\n", st[i].name, st[i].age);
         }
     }

     return ;
 }

--------------------------------------
//也可以定义一个结构体数组的同时进行初始化

struct student st[];    //这句话的意思是：定义一个结构体数组，有3个成员，每个成员类型都是struct student的。

struct student st[] = { {"刘德华", , }, {"安倍", , }, {"苍老师", , } };
输出结果是：
刘德华, , 男
安倍, , 女
苍老师, , 女

struct student st[] = { {"刘德华", , }, {"安倍", , } };
输出结果是：
刘德华, , 男
安倍, , 女
, , 女

struct student st[] = { {"刘德华", , }, {"安倍", , } };

    //此时循环条件需要变一下。如下：
    for (i = ; i < sizeof(st) / sizeof(st[]); i++)
    {

    }

-----------------------------------------------------------------------------
//小练习：把一个结构体数组按照年龄大小排序。
//方法：使用冒泡排序结构体数组。

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     unsigned char age;
     int sex;
 };

 void swap_str(char *a, char *b)
 {
     char tmp[] = {  };
     strcpy(tmp, a);
     strcpy(a, b);
     strcpy(b, tmp);
 }

 void swap_int(int *a, int *b)
 {
     int tmp = *a;
     *a = *b;
     *b = tmp;
 }

 int main()
 {
     struct student st[] = { { "刘德华", ,  }, { "苍井空", ,  }, { "陈冠希", ,  } };
     int i, j;
     for (i = ; i < sizeof(st) / sizeof(st[]); i++)
     {
         for (j = ; j < sizeof(st) / sizeof(st[]) - ; j++)
         {
             if (st[j].age < st[j - ].age)
             {
                 swap_str(st[j].name, st[j - ].name);
                 swap_int(&st[j].age, &st[j - ].age);
                 swap_int(&st[j].sex, &st[j - ].sex);
             }
         }
     }

     for (i = ; i < sizeof(st) / sizeof(st[]); i++)
     {
         if (st[i].sex == )
         {
             printf("%s, %d, 男\n", st[i].name, st[i].age);
         }
         else
         {
             printf("%s, %d, 女\n", st[i].name, st[i].age);
         }
     }

     return ;
 }
 输出结果是：
 苍井空, , 女
 刘德华, , 男
 陈冠希, , 男

=============================================================================
6、结构体的嵌套

　　一个结构的成员还可以是另外一个结构体类型。

vs2017下示例代码如下：

 #include <stdio.h>

 struct A
 {
     char a1;
 };

 struct B
 {
     struct A a;
     char a2;        //如下图所示：
     int a1;
 };

 //error C2016 : C 要求一个结构或联合至少有一个成员。
 //但是在c++中，下面这个语法是成立的。大小为1个字节。
 /*
 struct D
 {

 };
 */

 //注意与上面的区别：
 struct A1
 {
     int a1;
     char a2;
 };

 struct A2
 {
     struct A1 a1;
     char a2;        //上面结构体变量是作为一个整体存在的，占用了8个字节。不可能把a2补到结构体a1的后面去的，所以此时的a2是单独的一个对齐单位。如下图所示：
     int a3;
 };

 int main()
 {
     struct B b;
     printf("%u\n", sizeof(b));    //
     b.a.a1= ;
     b.a2 = ;
     printf("%p\n", &b.a.a1);    //005FF8B4

     struct A2 a2;
     printf("%u\n", sizeof(a2));    //

     return ;
 }

如下图所示：结构体嵌套说明

=============================================================================
7、结构体的赋值

结构体变量之间的赋值就是简单的结构体变量之间的内存拷贝。
=============================================================================
8、通过指针访问结构体成员(即指向结构体的指针)

　　-> 操作符
　　(*p).a 等同于 p->a

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 int main()
 {
     struct student st1 = { "abc",  };
     struct student st2;
     st2 = st1;    //结构体变量之间的赋值就是简单的结构体变量之间的内存拷贝。等价于下句：
     //memcpy(&st2, &st1, sizeof(st1));
     printf("%s, %d\n", st2.name, st2.age);    //abc, 30

     struct student *p;
     p = &st1;    //通过指针访问结构体成员(即指向结构体的指针)
     //strcpy((*p).name, "hello");
     //(*p).age = 50;
     strcpy(p->name, "hello");
     p->age = ;
     printf("%s, %d\n", st1.name, st1.age);    //hello, 50

     return ;
 }

=============================================================================
9、通过指针访问结构体数组(即指向结构体数组的指针)

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 int main()
 {
     struct student st[] = { { "张三",  }, { "李四",  }, { "王二麻子",  } };
     struct student *p = st;
     p->age = ;
     p++;
     p->age = ;
     p--;

     int i;
     for (i = ; i < ; i++)
     {
         printf("%s, %d\n", p[i].name, p[i].age);
     }

     return ;
 }

=============================================================================
10、结构体变量的指针成员与浅拷贝、深拷贝的操作(即结构中的数组成员和指针成员)

　　一个结构中可以有数组成员，也可以有指针成员；
　　如果是指针成员，结构体成员在初始化和赋值的时候就需要提前为指针成员分配内存！

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 struct man
 {
     char *name;
     int age;
 };

 //浅拷贝。
 int main()
 {
     struct student st = {  };
     struct student st1 = {  };
     strcpy(st.name, "刘德华");
     st.age = ;
     st1 = st;    //结构体变量之间的赋值就是简单的结构体变量之间的内存拷贝。
     printf("%s, %d\n", st1.name, st1.age);    //刘德华, 30

     struct man m = {  };    //m里面的name是什么？答：是空指针null。没有指向有效地址，就不能进行strcpy的操作。用堆内存解决如下：
     struct man m1 = {  };
     m.name = calloc(, sizeof(char));    //因为struct man里面的name是char *，即通过堆内存分配空间的地址编号给它，它才能进行strcpy的操作。
     strcpy(m.name, "张学友");
     m.age = ;

     m1 = m;        //浅拷贝。结构体变量之间的赋值就是简单的结构体变量之间的内存拷贝。
     free(m.name);    //把m.name释放掉了，m1就指向了一块未知的空间了。变成野指针了。输出就变成未知的了。
     printf("%s, %d\n", m1.name, m1.age);    //葺葺葺葺葺葺葺葺葺葺葺葺, 40

     return ;
 }
 浅拷贝说明如下图所示：
 

 //深拷贝。
 int main()
 {
     struct student st = {  };
     struct student st1 = {  };
     strcpy(st.name, "刘德华");
     st.age = ;
     st1 = st;    //结构体变量之间的赋值就是简单的结构体变量之间的内存拷贝。
     printf("%s, %d\n", st1.name, st1.age);    //刘德华, 30

     struct man m = {  };    //m里面的name是什么？答：是空指针null。没有指向有效地址，就不能进行strcpy的操作。用堆内存解决如下：
     struct man m1 = {  };
     m.name = calloc(, sizeof(char));    //因为struct man里面的name是char *，即通过堆内存分配空间的地址编号给它，它才能进行strcpy的操作。
     strcpy(m.name, "张学友");
     m.age = ;

     m1.name = calloc(, sizeof(char));
     memcpy(m1.name, m.name, );    //深拷贝。
     m1.age = m.age;
     free(m.name);
     printf("%s, %d\n", m1.name, m1.age);    //张学友, 40
     free(m1.name);

     return ;
 }

=============================================================================
11、在堆中创建的结构体变量

　　如果结构体中有指针类型成员，同时结构体在堆中创建，那么释放堆中的结构体之前需要提前释放结构体中的指针成员指向的内存。

vs2017下示例代码如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];    //这个不在内存里，这是c语言的写法而已，还没有成为变量，只能叫结构体，只有在代码中明确定义后才成为结构体变量了。
     int age;
 };

 struct man
 {
     char *name;
     int age;
 };

 int main()
 {
     struct student st = {  };    //请问st.name在堆里面还是栈里面？答：在栈里面。    ((*p).name 等价于 p->name)
     struct student *p = malloc(sizeof(struct student));    //请问(*p).name在栈里面还是在堆里面？答：在堆里面。因为本句等价于，如下：
     //struct student *p;
     //p = malloc(sizeof(struct student));
     free(p);

     struct man *p1 = malloc(sizeof(struct man));    //p1->name在栈里还是堆里？答：在堆里面，但是是一个野指针！需要进行驯化！
     p1->name = malloc();
     strcpy(p1->name, "苍老师");
     p1->age = ;
     printf("%s, %d\n", p1->name, p1->age);    //苍老师, 20
     free(p1->name);    //先释放p1->name的堆内存。
     free(p1);        //再释放p1的堆内存。

     return ;
 }

在堆中创建的结构体变量中有指针变量和无指针变量时的内存说明图，如下：

=============================================================================
12、将结构体作为函数的参数、将结构体的指针作为函数的参数

　　在定义一个和结构体有关的函数时，到底是使用结构体，还是使用结构体的指针呢？
　　答：指针作为参数时，只需要传递一个地址，所以代码效率高。

vs2017下示例代码如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct student
 {
     char name[];
     int age;
 };

 void set_student(struct student st)
 {
     strcpy(st.name, "");
     st.age = ;
 }

 void set_student01(struct student *st)
 {
     strcpy(st->name, "");
     st->age = ;
 }

 void print_student(struct student st)    //因为st是形参，当调用该函数的时候，在栈里面会有一个浅拷贝的过程，是结构体变量之间的赋值，即st = s;
 {                                        //假如结构体变量很大时，拷贝的代价很大，并不好！如何优化提升效率呢？如下：
     printf("%s, %d\n", st.name, st.age);
 }

 //既然函数的形参是指针，我们不希望被内部改变，那就一般加上const。
 void print_student_new(const struct student *st)    //st = &s;    //相当于一个整数的赋值。
 {
     printf("%s, %d\n", st->name, st->age);
 }

 int main()
 {
     struct student s = { "abc",  };
     set_student(s);        //s的值在函数调用完成之后会改变吗？答：不会，因为形参的值的改变不会影响实参的值。
     set_student01(&s);    //那么现在就想通过形参的值来改变实参的值，怎么办呢？答：用指针即可。

     //print_student(s);
     print_student_new(&s);

     return ;
 }

=============================================================================
=============================================================================
二、联合体

　　联合 union 是一个能在同一个存储空间存内储不同类型数据的类型。

　　联合体所占用内存的长度等于其最长成员的长度，有时也叫做共用体。

　　联合体虽然可以有多个成员，但同一时间只能存放其中的一种。

vs2017下示例代码如下：

 #include <stdio.h>

 union A
 {
     int a1;
     short a2;
     char a3;
     int a4;
     int a5;

     char *p;
 };

 int main()
 {
     union A a;
     a.a1 = ;
     printf("%u\n", sizeof(a));    //
     printf("%p, %p, %p\n", &a.a1, &a.a2, &a.a3);    //012FFD70, 012FFD70, 012FFD70

     a.a3 = ;
     a.a1 = ;
     printf("%d\n", a.a3);        //

     a.a1 = 0x12345678;
     a.a3 = ;
     printf("%x\n", a.a1);        //

     a.a1 = 0x12345678;
     a.a2 = ;
     printf("%x\n", a.a1);        //

     a.p = malloc();    //假设这块内存的编号为0x12345。此时p的值为0x12345，即：*p = 0x12345;
     a.a1 = ;            //因为它们共享一块内存，所以就导致了p的值也成了0了，即：*p = 0。
     free(a.p);            //那么用malloc申请的堆内存不能够被free了，且申请的堆内存丢失了，找不着。

     return ;
 }

=============================================================================
=============================================================================
三、枚举类型

1、c语言中枚举的定义

　　c语言中的枚举比较松散，c++语言中的枚举比较严谨。

　　可以使用枚举(enumerated type)声明代表整数常量的符号名称，关键字enum创建一个新的枚举类型。

　　实际上，enum常量是int类型的。

　　枚举的基本用法：可以快速的去定义很多整型常量，使得代码可读性又得以增强。

vs2017下示例代码如下：

 #include <stdio.h>
 #include <string.h>
 #pragma warning(disable:4996)

 //用宏常量的方法，使得代码可读性增强。但是呢，如果要定义的常量特别多呢，用宏定义就不方便了。答：那就用枚举。
 //#define WOMAN 0
 //#define MAN 1

 //枚举的基本用法：可以快速的去定义很多整型常量，使得代码可读性又得以增强。
 enum sex { woman, man, intersex, shemale };

 struct man
 {
     char name[];
     int age;
     int sex;
 };

 int main()
 {
     struct man m;
     strcpy(m.name, "tom");
     m.age = ;
     //m.sex = MAN;    //m.sex = 1;

     enum sex s;    //在c语言中，左边这三句等价于一句，如下：
     s = man;    //m.sex = man;
     m.sex = s;

     printf("%d, %d\n", man, shemale);    //1, 3
     //man = 6;            //不能这么写，因为man是一个整型的常量，常量不能作为左值的。
     //int *p = &man;    //也不能这么写，因为man是一个整型的常量，常量是不能取地址的。等同于,如下所示：
     //int *p = &100;    //因为100本身在系统内是由cpu产生的立即数(cpu中有立即数发生器)，不在内存里面。
     //const char *p = "hello";    //"hello"是一个字符串常量，又因为cpu不能自动生成这样一个字符串，在内存的常量区里面。
     //int a = 100;        //这句话映射到cpu底层的意思是：cpu生成一个立即数100，cpu在内存的栈中分配一个4个字节的空间，然后把这个空间的值设置为100。

     return ;
 }

=============================================================================
2、改变枚举的默认值

enum sex { woman, man = , intersex, shemale };
, , , 

enum sex { woman, man, intersex, shemale =  };
, , , 

=============================================================================
=============================================================================
四、typedef

　　typedef是一种高级数据特性，它能使某一类型创建自己的名字。
　　为了简化代码，简化语法，增加可读性、可维护性，减少代码量。

typedef的特点是：
　　1、与#define不同，typedef仅限于数据类型，而不能是表达式或具体的值。
　　2、typedef是编译器处理的，而不是预编译指令。
　　3、typedef比#define更灵活。

vs2017下示例代码如下：

 #include <stdio.h>

 typedef unsigned char BYTE;

 struct man
 {
     char name[];
     BYTE age;    // unsigned char age;
 };

 typedef struct man M;
 typedef short SHORT;

 int main()
 {
     M m;        //struct man m;
     m.age = ;
     BYTE a = ;    //unsigned char a = 0;

     SHORT a1;    //short a1;
     SHORT a2;    //short a2;
     SHORT a3;    //short a3;
     SHORT a4;    //short a4;
     SHORT a5;    //short a5;

     return ;
 }

=============================================================================
题外话：在现代编程里面，微软在出很多版本的windows时不需要维护很多源代码。他每次通过某些宏来实现。
　　当一个项目做得特别大时，做完后还得需要去维护、去升级、去修改。
　　微软一开始就把代码写的很优秀，一开始就把c语言能用的构架都给用了，那么最后再去维护代码的时候，就会很容易。
　　其实都是通过c语言这些基本的关键字来实现的。

　　他们不是必须的，但是有的时候有了这些构架后，会发现工作效率会提升很多，所以换个角度说，这些前期工作有时必须的。
　　我们在写程序时，既要实现功能本身，又要有高效的产出。

//wchar_t是2个字节的字符类型，在宽码操作系统内部处理字符串的时候一般用wchar_t。
//在不是宽码操作系统内部处理字符串的时候一般用char。
--------------------------------------
#ifdef UNICODE
typedef wchar_t TCHAR;
#else
typedef char TCHAR;
#endif
--------------------------------------
#define UNICODE

int main()
{
　　TCHAR s[100];
　　return 0;
}
=============================================================================
课堂练习：在堆中处理结构体的指针成员

vs2017下示例代码如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct man
 {
     char *name;
     int age;
     int classid;
 };

 int main()
 {
     struct man *p = calloc(, sizeof(struct man));        //在堆内存中分配了10个连续的man。相当于别样的数组！

     int i;
     for (i = ; i < ; i++)
     {
         printf("please input name:");
         char tmp[] = {  };
         scanf("%s", tmp);
         p[i].name = malloc(strlen(tmp) + );
         strcpy(p[i].name, tmp);

         printf("please input age:");
         scanf("%d", &p[i].age);

         printf("please input classid:");
         scanf("%d", &p[i].classid);
     }

     for (i = ; i < ; i++)
     {
         printf("%s, %d, %d,\n",p[i].name, p[i].age, p[i].classid);
         //free(p[i].name);    //分别释放离散的堆内存空间。放到这也可以。
     }

     for (i = ; i < ; i++)
     {
         free(p[i].name);    //分别释放离散的堆内存空间。
     }
     free(p);    //一次性释放连续的堆内存空间（其实就是堆中的数组）。

     return ;
 }

课堂练习：在堆中处理结构体的指针成员_堆内存占用如下图所示：

-----------------------------------------------------------------------------
改进：到底堆中有多少个数组成员，不确定，取决于用户的输入，用户输入3个人，就有3个成员，用户输入100个人就有100个成员。

vs2017下示例代码如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #pragma warning(disable:4996)

 struct man
 {
     char *name;
     int age;
     int classid;
 };

 int main()
 {
     struct man *p = NULL;    //calloc(3, sizeof(struct man));//在堆内存中分配了10个连续的man。相当于别样的数组！

     //int i;
     //for (i = 0; i < 3; i++)

     int i = ;
     while()
     {
         printf("please input name:");
         char tmp[] = {  };
         scanf("%s", tmp);
         //如果用户输入的名字等于exit，则我们就退出循环。
         if (strcmp(tmp, "exit") == )
         {
             break;
         }

         p = realloc(p, sizeof(struct man) * i);
         p[i - ].name = malloc(strlen(tmp) + );
         strcpy(p[i - ].name, tmp);

         printf("please input age:");
         scanf("%d", &p[i - ].age);

         printf("please input classid:");
         scanf("%d", &p[i - ].classid);

         i++;
     }

     int a;
     for (a = ; a < i - ; a++)
     {
         printf("%s, %d, %d,\n",p[a].name, p[a].age, p[a].classid);
     }

     for (a = ; a < i - ; a++)
     {
         free(p[a].name);    //分别释放离散堆空间。
     }
     free(p);    //一次性释放连续的堆内存空间（其实就是堆中的数组）。

     return ;
 }

例如：
　　int a[20];//这个数组一旦定义，那么就不能改变他的大小，因为栈里面的数组都不能动态改变大小。那就用堆。

=============================================================================
=============================================================================