引入

如果学习过数据结构，就会知道，链表是一种常见的重要的数据结构。它是动态的进行存储分配的一种结构。
在前面的学习中，我们知道，用数组存放数据时，必须线定义数组长度，也就是数组中元素的个数。
那么如果我们用来存储班级人数，有的班级100人，有的班级30人，那么为了能放下100人的数据，我们必须设计一个100个元素的数组。显然，这会浪费很多内存。
链表，就没有这种缺点，它根据需要开辟存储单元。

链表

我们先来看一个链表

• head ：表示链表中的头指针变量。它存放一个地址，该地址指向一个元素。链表中的每一个元素，称为结点；
• 节点 ：表示链表中的每一个元素，每个结点都应该包含两个部分:
  1.是用户所需要用的实际数据
  2.是下一个结点的地址。

上面的图中，head 是头指针，指向第1个元素
第1个元素指向第2个元素，以此类推
直到最后一个元素，该元素不再指向其它元素，它称为表尾
表尾的地址部分存放的地址为：NULL
链表到此结束

引入

前面，我们知道了什么是结构体变量和结构体变量的指针，那么它们能不能在形参中出现，接收主调函数传递过来的值呢？我们现在就一起来看看~

将结构体变量的值传递给另一个函数

其实，结构体变量和结构体变量的指针，甚至结构体变量的成员都可以作为函数参数来使用。

结构体变量的成员作为实参

例如使用 stu[1].name stu[3].num 等结构体变量的成员作为函数参数，进行虚实结合，跟普通变量一样，属于值传递的方式。

注意： 实参和形参的类型要保持一致。

用结构体变量作为实参

用结构体变量做实参，也是采用值传递的方式，结构体变量所占的内存单元的内容全部按顺序传递给形参。所以，形参必须也是相同的结构体类型。

引入

我们知道，指针就是地址，那么结构体指针呢？其实就是指向结构体变量的起始地址，就是这个结构体变量的指针。相反的，如果吧结构体的起始地址存放在一个指针的，那么这个指针就指向该结构体变量。

定义

指向结构体对象的指针：
即可以指向结构体数组中的元素；
也可以指向结构体变量。

struct Student *student_1;
// student_1 指向 struct Student 类型的变量或者数组元素

例子

通过指向结构体变量的指针变量，来输出结构体内各成员的信息

#include <stdio.h>
int main(){
    struct Student{
        int num;
        char name[20];
        int score;
    };
    struct Student stu_1={1,"Bliner",99};
    struct Student *stu_p;
    stu_p=&stu_1;
    printf("学号是：%d\n姓名是：%s\n成绩是：%d\n\n",stu_1.num,stu_1.name,stu_1.score);
    printf("指针方式输出\n学号是：%d\n姓名是：%s\n成绩是：%d\n",(*stu_p).num,(*stu_p).name,(*stu_p).score);
}

引入

前面，我们学习了如何声明一个结构体类型和初始化结构体变量，那么数组能不能设置为结构体类型呢？答案是肯定的，这就是结构体数组。结构体数组和普通数组的最大区别就是，每个数组元素其实都是一个结构体类型的数据，因为数组是结构体类型。

例子

三个候选人，10张选票，我们设计一个统计选票的程序，输入10个选票的结果，输出统计数量。

#include <stdio.h>
#include <string.h>
int main(){
    struct People{
        char name[20];
        int count;
    }leader[3]={"a",0,"b",0,"c",0};
    char leader_name[20];
    for (int i=0;i<10;i++){
        scanf("%s",leader_name);
        for (int j=0;j<3;j++){
            if(strcmp(leader_name,leader[j].name)==0){
                leader[j].count++;
            }
        }
    }
    printf("最终结果是：\n");
    for(int i=0;i<3;i++){
        printf("%s 获得 %d 票 !\n",leader[i].name,leader[i].count);
    }
    return 0;
}

引入

前面，我们已经学习了三种声明结构体变量的方式，今天我们来学习如何给结构体变量赋初始值和输出该结构体成员的值。

例子

把一个学生信息放在一个结构体变量中，然后输出这个学生的信息。

#include <stdio.h>
int main(){
    struct Student{
        int num;
        char name[20];
        char sex;
        int age;
        char addr[50];
    }student_1={001,"Bliner",'M',26,"China,Beijing"};
    printf("No.%d\n姓名：%s\n性别：%c\n年龄%d\n家庭住址：%s\n",student_1.num,student_1.name,student_1.sex,student_1.age,student_1.addr);
    return 0;
}

输出结果：

No.1
姓名：Bliner
性别：M
年龄26
家庭住址：China,Beijing

引入

前面，我们讲了如何建立一个结构体类型，但是并没有定义变量，系统也不分配具体的内存单元。我们可以采用以下3种方法定义结构体类型变量。

先声明结构体类型，再定义该类型变量

没有这个类型，就声明这个类型，然后再定义这个类型的变量。这种声明方式最常用和简单，声明和定义分离，声明后可以随时定义变量，比较灵活。

#include <stdio.h>
int main(){
struct Student{
int num;
char name[20];
char sex;
int age;
};

struct Student student_1,student_2;
//定义 student 结构体类型的变量
int student_1,student_2;
//和普通定义整型变量很像，struct Student 就等同于 int 
}

引入

前面我们所见到的程序中，变量都是独立存在的，我们定义 a、b、c，那他们就只是单独存在的变量而已，在内存中的地址也是互不相干的~但是~~
实际生活中，有些数据是有内在联系的，成组出现的。
例如，一个学生，可能包含：

学号、姓名、性别、年龄、成绩、家庭地址等

这些信息往往是成组的出现。
所以，我们希望把这些数据合并在一起，成为一个组合数据，例如组成数据 student_1 的变量，这个变量中就包含了学号为1的学生的上述信息，这样我们写入和调用时就方便多了！

为什么数组不行

一个变量名，包含多重信息，咦，这不是跟数组很像吗？为什么不用数组来解决这个问题呢？因为：

数组的每个元素的数据类型是相同的，我们需要的显然是不同类型的数据，例如 姓名 和 学号。

所以，为了解决这个问题，C 语言就允许用户自己建立由不同类型数据组成的组合型数据结构，它称为结构体。
在其它的高级语言中，称为记录。

举个例子

我们根据上面学生的例子，亲手建立一个结构体。

struct Student
{ 
int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
};  //注意，这里有一个分号

总结

指针的概念比较多，抽象并且复杂，我们再把这一部分的内容回顾一下。

指针的含义

记住一句话，指针就是地址。
凡事指针出现的地方，都是用地址代替的。
变量的指针：变量的地址
指针变量：地址变量

常见变量

int a;  //定义整型变量 a
int *p;  //定义指针变量 p
int a[5];  //定义数组长度为5的整型数组 a
int *p[4];  //定义指针数组，数组存储的是4个地址，地址指向整型数据
int (*p)[4];  //定义了一个指向一维数组的指针，这个一维数组包含4个元素。
int f();  //定义了一个整型函数 f，没有参数。
int *p();  //定义了一个返回值为指针的函数 p，指针指向整型。
int (*p)();  //定义了一个指向函数的指针 p，该函数返回值为整型
int **p;  //定义了一个指向指针的指针，指针指向的是整型。
void *p;  //定义了一个不指向任何对象的指针变量 p。

什么是内存的动态分配

还记得我们之前讲过的全局变量和局部变量吗？全局变量是分配在内存中的静态存储区的，非静态的局部变量（包括形参）都是分配在内存的动态存储区的。我们称上面的存储区为 栈 (stack) 。
除此之外，C 语言还允许建立内存动态分配区域，存放一些临时用的数据，这些数据：

1. 不必在程序的声明部分定义；
2. 不必等到函数结束时才释放；
3. 需要时开辟，不需要时随时释放；

这些数据是临时存放在一个特别的自由存储区，称之为堆 ( haap)。

我们可以根据需要，随时向系统申请所需大小的空间，但是我们没有声明他们是变量还是数组，也没有名字，所以我们只能通过指针来引用这些数据。

建立内存的动态分配

清楚了什么是动态分配之后呢，我们来看看如何建立这么一个叫做堆的区域。
我们对内存的动态分配，主要是通过系统功能提供的库函数来实现的，主要有malloc , calloc , free , realloc 这4个。

malloc 函数

函数原型：

void * malloc( unsigned int size);

引入

前面我们学习过指针数组，即数组的元素都是由指针地址组成的数组，指针数组可以很好的存储长度不同的数组地址，从而进行调用。但是指针数组最重要的作用是作为 main 函数的形参来使用的，今天我们就来看看。

main 函数中的参数

我们知道 main 函数的一般形式是

int main(){
....
return 0;
}
// 或者
int main(void){
...
return 0;
}

也就是说，main 函数的默认形参实际上是不存在的，也就是说，调用 main 函数的时候不用给出实参传递给 main 函数的形参。
在有些情况下，实际上 main 函数可以有参数的。

int main(int argc, char * argv[])