数据结构预备知识

一、指针

概念：指针=地址=内存单元的编号

把内存划分为一个个的内存单位，每个内存单元的大小取1个字节。

每个内存单元也都有一个编号即地址，有了这个内存单元的编号，CPU就可以快速找到一个内存空间。

1、指针变量

地址该如何存储起来呢？

指针变量存放地址（指针）eg int *pa

*是在说明pa是指针变量，而前面的int是在说明pa指向的是整型类型的对象。

2、野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

如何规避野指针？

如果明确知道指针指向哪里就直接赋值地址。

如果不知道指针指向哪里，可以给指针赋值NULL。

3、指针的使用和传址调用

函数的调用：

传址调用：函数在调用的时候传递的是地址。

                 传址调用时，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量。

传值调用：传的是地址本身。

                 传值调用函数时，函数的实参传给形参时，形参是实参的一份临时拷贝！形参有自己独立的空间，对形参的修改不会影响实参！

所以未来函数中只需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用。

二、结构体

1、结构体成员的间接访问

有时候我们得到的不是一个结构体变量，而是得到了一个指向结构体的指针。

使用方式：结构体指针->成员名

#include <stdio.h>
#include <string.h>
struct Stu
{
char name[15];//名字
int age; //年龄
};
void print_stu(struct Stu s)
{
printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)
{
strcpy(ps->name, "李四");
ps->age = 28;
}
int main()
{
struct Stu s = { "张三", 20 };
print_stu(s);
set_stu(&s);
print_stu(s);
return 0;
}

2、结构体的自引用

在结构体中包含一个类型为该结构本身的成员是否可以呢？

例如，定义一个链表的节点：

struct Node
{
int data;//存放数据
struct Node* next;//存放下一个结点的地址
};

3、结构体传参

结构体传参的时候，要传结构体的地址

struct S
{
int data[1000];
int num;
}；
struct S s = {{1,2,3,4}, 1000};
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
 print2(&s); //传地址
return 0;
}

三、动态内存管理

1、为什么要有动态内存分配

有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

2、malloc

void* malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。 

​#include <stdlib.h>
int main()
{
//void *p=malloc(40);我们只知道申请多大的空间，但是不知道回放什么类型的数据
//void* 指针不能进行加加减减 但程序员自己知道放的类型
int *p=(int *)malloc(40);
if(p==NULL)
{
perror("malloc");
return 1;
}
int i=0;
for(i=0;i<10;i++)
{
*(p+i)=i;
}
//打印
for(i=0;i<10;i++)
{
printf("%d ",*(p+i)=i);//0 1 2 3 4 5 6 7 8 9
}
return 0;
}

如果开辟成功，则返回⼀个指向开辟好空间的指针。
 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。

3、free

malloc/calloc/realloc申请的空间，如果不主动释放，除了作用域是不会销毁的

释放的方式：

（1）free主动释放

(2)直到程序结束，才有操作系统回收

void free (void* ptr);

free函数⽤来释放动态开辟的内存。
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。

#include <stdio.h>
#include <stdlib.h>
int main()
{
int num = 0;
scanf("%d", &num);
int arr[num] = {0};
int* ptr = NULL;
ptr = (int*)malloc(num*sizeof(int));
if(NULL != ptr)//判断ptr指针是否为空
{
int i = 0;
for(i=0; i<num; i++)
{
*(ptr+i) = 0；
}
}
free(ptr);//释放ptr所指向的动态内存
ptr = NULL;//是否有必要？
//ptr还记着起始地址 为了避免ptr为野指针 置为空指针
//free没能力把ptr置为空
return 0;
}

3、calloc

void* calloc (size_t num, size_t size);

• 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

举个例⼦：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
int i = 0;
for(i=0; i<10; i++)
{
printf("%d ", *(p+i));
}
}0 0 0 0 0 0 0 0 0 0
free(p);
p = NULL;
return 0;
}

4、malloc与calloc的区别

（1）参数不一样

（2）malloc只负责开辟空间，而calloc开辟好空间后将每个字节初始化为0
 

5、realloc

• realloc函数的出现让动态内存管理更加灵活。
• 有时我们会发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的内存，我们⼀定会对内存的⼤⼩做灵活的调整。那 realloc 函数就可以做到对动态开辟内存⼤⼩的调整。
函数原型如下：

void* realloc (void* ptr, size_t size);

• ptr 是要调整的内存地址
• size 调整之后新⼤⼩
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到新的空间。

•realloc调整空间失败返回NULL
• realloc在扩容时成功的两种常见情况：
◦ 情况1：原有空间之后有⾜够⼤的空间

在已经开辟好的空间后边，有足够的空间直接进行扩容，扩大空间后，直接返回旧的空间的起始地址。
◦ 情况2：原有空间之后没有⾜够⼤的空间

在已经开辟好的空间后边，没有足够的空间直接进行空间的扩大，在这种情况下，realloc函数会在内存的堆区重新找一个空间（满足新的空间的大小需求的），同时会把旧的数据拷贝到新空间，然后释放旧的空间，同时返回新的空间的起始地址。

使用relloc函数需注意：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *ptr = (int*)malloc(100);
if(ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
//代码1 - 直接将realloc的返回值放到ptr中
ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
//代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
int*p = NULL;
p = realloc(ptr, 1000);
if(p != NULL)
ptr = p;
}
//业务处理
free(ptr);
return 0;
}

6、常见的动态内存的错误

后面的代码为修改正确的

（1）对NULL指针的解引用操作

void test()
{
int *p = (int *)malloc(INT_MAX/4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}

int main()
{
int *p=(int*)malloc(100);
if(p==NULL)
{
//报错信息
perror("malloc");
return 1;
}
*p=20;//p有可能是NULL指针
//释放
free（p);
p=NULL;
return 0;
}

(2)对动态开辟空间的越界访问

void test()
{
int i = 0;
int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{
exit(EXIT_FAILURE);
}
for(i=0; i<=10; i++)
{
*(p+i) = i;//当i是10的时候越界访问
}
free(p);
}

（3）对非动态开辟内存使用free释放

void test()
{
int a = 10;
int *p = &a;
free(p);//ok?
}

（4）使用free释放一块动态开辟内存的一部分

void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}

（5）对同一块动态内存多次释放

void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}

（6）动态开辟内存忘记释放（内存泄漏）

void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}

忘记释放不再使⽤的动态开辟的空间会造成内存泄漏。
切记：动态开辟的空间⼀定要释放，并且正确释放。

7、动态内存经典笔试题分析

问运行Test函数会有什么样的结果？存在的问题

（1）

void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}

  

GetMemory函数采用值传递的方式，无法将malloc开辟空间的地址返回在str中，调用结束后str依然是NULL

strcpy中使用了str，就是对NULL指针解引用操作，程序崩溃

内存泄漏

void GetMemory(char **p)
{
*p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str=NULL;
}

（2）

char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}

出了函数后空间不可使用 str为野指针

（3）

void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}

未释放 free(str)；str=NULL;

（4）

void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}

str并未置为空 str为野指针 str非法访问