上一篇：从0开始学c语言-32-自定义类型：结构体，枚举，联合_阿秋的阿秋不是阿秋的博客-CSDN博客

目录

动态内存管理

1. 为什么存在动态内存分配

2. 动态内存函数的介绍

2.1 malloc和free

malloc

free

应用

和数组的区别

2.2 calloc

2.3 realloc

变大

变小

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

3.2 对动态开辟空间的越界访问

3.3 对非动态开辟内存使用free释放

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

3.5 对同一块动态内存多次释放

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

4. 几个经典的笔试题

4.1 题目1：

查阅资料：

编译器角度入手

改善

4.2 题目2：

 4.3 题目3：

4.4 题目4：

4.5 题目5：

4.6 题目6：

5. C/C++程序的内存开辟

放个喜欢的图，哈哈哈，内容很长，主要是写给我自己复习看的。

动态内存管理

        其实内存里有三个区，每个区放不同的东西。我们的动态内存分配就是在堆区开辟空间的。

1. 为什么存在动态内存分配

我们已经学过的在栈区开辟内存空间的方式有

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

1. 空间开辟大小是固定的。

2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

2.1 malloc和free

malloc

void* malloc (size_t size); //size单位是字节

        如果开辟成功，则返回一个指向开辟好空间的指针。

        如果开辟失败，则返回一个NULL 指针， 因此malloc的返回值一定要做检查 。

        返回值的类型是 void* ，所以 malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定（加上强制类型转换）。

        如果参数 size 为 0 ， malloc 的行为是标准是未定义的（也就是说，没必要搞这种没意义的数字去试探函数的反应），这种结果取决于编译器。

free

void free (void* ptr);

（malloc和free都声明在 stdlib.h 头文件中。 ）

应用

假设我们现在要开辟10个int类型的空间

如果是在栈区开辟，那么写一个数组就好了

int arr[10]; //栈区

主要演示动态内存怎么开辟，首先需要malloc来申请空间，

void* malloc (size_t size); //size单位是字节

因为要开辟10个int，那么void* malloc (size_t size); 当中的size便确定了，写成下面这样。

malloc(10*sizeof(int));

我们前面介绍过这个函数会返回一个指向开辟好空间的指针，那么现在我们需要用一个指针来接收它返回的地址。因为是int类型的空间，所以我们用int*指针来接收。又因为返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定（加上强制类型转换）。所以我们写成了下面这样。

int* p = (int*)malloc(10 * sizeof(int));

学到这里你是不是觉得，好像这个开辟空间的方式怎么和数组差不多呢？

我们知道数组名是首元素的地址，其实就是指向首元素的指针，在int数组中的数组名就是int*指针。而现在我们接收【开辟动态内存返回值】的 p指针变量 仿佛就是这10个int类型的数组名，p指向首元素，是int*类型的指针。

简单提一下，让你更理解数组。

若开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("main"); //用来报错
		return 0;
	}

接着，我们试着使用一下。

int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
		printf("%d ", p[i]); //p[i] <=> *(p+i)
	}

你会发现，10个int的空间就相当于一个int[10]类型的数组。

现在进行空间释放。使用free函数把p指针指向的动态内存空间回收掉，但是p指针还存放着这块空间的地址，所以释放后我们还需要把这个指针置位空指针，否则它就是个野指针。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int arr[10]; //栈区
	//动态内存开辟
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 0;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
		printf("%d ", p[i]);
	}
	//回收空间
	free(p);
	p = NULL; //不置为空指针，p就会成为野指针
	return 0;
}

这就是比较完整的使用过程了，

1·开头【开辟空间后】 的 指针接收 和 强制类型转换，以及检查是否开辟失败进行报错。

2·结尾的 回收空间，置为空指针

这两个步骤很关键。

和数组的区别

我上面说这个和数组很像，但是并不完全一样。

用这段代码和你说，先和你说calloc开辟的空间会初始化为0，因为我之前说p指针变量好像就和数组名一样，都指向首元素的地址，后面都是9个连续的int空间，所以我进行了如下探索。

int main()
{
	int arr[10] = { 0 };
	int* p = (int*)calloc(10 ,sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 0;
	}
	//使用
	while (*p++ == *arr++)
		printf("qiu");
	//释放空间
	free(p);
	p = NULL; //不置为空指针，p就会成为野指针
	return 0;
}

结果发现数组名是不能改变的指针，而p指针是可以改变的。

虽然p指针和arr数组名都可以做到*（p+i）和*（arr+i）来访问并改变元素内容，但是数组名arr这个指针本身并不能被改变，而指针p却是可以改变的。

这大概就是为什么数组大多都是函数传参过去实现更多功能的原因了，因为虽然数组名可以当做指针用，但是我们并不希望在使用的时候改变数组名指向的地址位置，同时却又希望利用数组首元素地址来实现更多功能，如下。

2.2 calloc

void* calloc (size_t num, size_t size);

1·函数的功能是为 num 个、每个元素大小为 size 的元素们开辟一块空间， 并且把空间的每个字节初始化为0 。

2·与函数 malloc 的区别只在于 calloc 会在返回地址之前 把申请的空间的 每个字节初始化为全0 。（malloc只是开辟，并不会初始化开辟的动态空间，未初始化之前都是随机值）

在使用方面，除了会初始化开辟的空间外，就是参数不太一样。

可以看到，如果都开辟10个int大小的空间，那么malloc的参数是40，而calloc的参数是（num）10个（size）大小为4byte的空间。本质上都是开辟了40个byte的空间，所达到的结果也一样，区别只有calloc会初始化开辟的空间。

 上面监视的窗口输入的是p，可别习惯性加个&写成&p，那就是 保存p指针 的地址了。

int main()
{
	//动态内存开辟
	/*int* p = (int*)malloc(10 * sizeof(int));*/
	int* p = (int*) calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 0;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	//释放空间
	free(p);
	p = NULL; //不置为空指针，p就会成为野指针
	return 0;
}

2.3 realloc

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

ptr 是要调整的内存地址

size 调整后的空间大小

返回值为调整之后的内存起始位置。

这个函数调整在原内存空间大小的基础上， 还会将原来内存中的数据移动到 新 的空间。

        情况2：原有空间之后没有足够大的空间

情况 1

        当是情况1 的时候，要扩展内存的时候就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况 2

        当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

（ realloc函数如果后面空间不够，就开辟新空间，拷贝原来数据，返回的地址是新开辟空间的地址。 如果找不到合适的空间，就会返回空指针。 ）

绿色代表reallloc函数开辟的空间，情况1有足够的空间来开辟，所以指针和空间都保存原有位置，返回的地址是原有空间的起始地址。

变大

情况二后面的空间不够了，我们会在堆区上找新的空间来开辟，并把原有空间的数据拷贝到这个新空间，返回一个指向新空间的地址。

 这是情况二的示范，记住这时候的空间是20000个int大小的空间，包含原有p指针指向的元空间大小。

int main()
{
	//动态内存开辟
	/*int* p = (int*)malloc(10 * sizeof(int));*/
	int* p = (int*) calloc(100, sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 0;
	}
	printf("%p\n", p);
	//使用时候想要在p指针后开辟更大的空间
//别直接用p接收realloc的返回值
//要用另一个指针接收
//为了防止找不到会返回NULL的情况
	int* ptr = realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	printf("%p\n", p);
	printf("%p\n", ptr);
	//释放空间
	free(p);
	p = NULL; //不置为空指针，p就会成为野指针
	ptr = NULL;
	return 0;
}

需要知道的是，如果我们给realloc函数传一个NULL指针过去，那么所实现的效果和malloc函数类似，就是直接在堆区开辟空间。

int* ptr = realloc(NULL, 20 * sizeof(int));

变小

然后示范一下变小的，可以看到就算空间变小，数据也不会变。

3. 常见的动态内存错误

可别觉得你不会犯这些错误，找不到问题的时候就可以照着这几条找。

3.1 对NULL指针的解引用操作

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

上面的代码就是忘记了对malloc函数的返回值进行NULL的检查，很容易会出问题。

3.2 对动态开辟空间的越界访问

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

3.3 对非动态开辟内存使用free释放

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

这样可不行哦，这个p指针是在栈区上申请空间的，而且free函数是专门释放在堆区动态开辟的内存空间的。可别乱用。

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

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

要注意前置后置++、- - 对于指针的作用，会改变指针的位置。

3.5 对同一块动态内存多次释放

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

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

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

动态开辟内存的两种回收方式：

1·主动free

2·程序结束

4. 几个经典的笔试题

4.1 题目1：

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

查阅资料：

 char *str = NULL;

 char *str = NULL;

void GetMemory(char *p) {
 p = (char *)malloc(100);
}

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

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

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

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

void Test(void) {
     char *str = NULL;
     str = GetMemory();
     printf(str);
}

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

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

int* f2(void)
{
    int* ptr;
    *ptr = 10;
    return ptr;
}

void test(int*arr)
{
	int*p= (int*)malloc(3 * sizeof(int));
	if (p != NULL)
	{
		arr = p;
	}
}
int main()
{
	int arr[] = { 1,2 };
	test(arr);
	*(arr + 2) = 3;
	printf("%d\n", *(arr + 2));
    free(arr);
    arr=NULL;
}