【C语言】——动态内存管理（适合进阶选手食用，超详细！！！）

观前提示：

1.为什么会存在动态内存管理

2.有哪些动态内存函数

2.1malloc函数和free函数

2.2calloc函数

2.3realloc函数

2.4realloc函数使用的两种情况

3.总结常见的动态内存错误问题

3.1对NULL指针的解引用操作

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

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

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

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

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

4.几个经典的笔试题（取自《高质量的C\C++编程》）

4.1题目1

4.2题目2

4.3题目3

4.4题目4

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

6. 柔性数组

1.柔性数组的特点：

2.柔性数组的使用

3.柔性数组的优势

7.总结

---

1.为什么会存在动态内存管理

        先看代码：

int main()
{
    int a = 10;  //在栈区上开辟4个字节的空间存10（局部变量）
    char arr[10] = { 0 }; //在栈区上开辟40个字节的空间存0（局部变量）
    return 0;
}

上述的两种开辟的空间有两个特点：

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

        2.数组在申明的时候，必须指定开辟空间的大小，它所需要的内存在编译时分配。

但是，对于空间的要求，不仅仅是上述的固定情况，有的时候对于程序到底需要多少空间，我们是在程序运行的时候才知道的。那么上述的开辟空间的方法就不适用了。

比如：

        我们需要用一个数组，我们事先不知道它必须要40个字节的空间，这个时候，假如我们开辟了20个字节的空间就不用，假如开辟400个字节的空间又太大了。浪费了空间。

因此：

        这个时候，我们需要灵活的改变开辟的内存空间，引入了动态内存函数的概念。所谓动态内存函数是指开辟一块连续的内存空间。

2.有哪些动态内存函数

2.1malloc函数和free函数

#include <stdlib.h>
void* malloc(size_t size)

对于malloc：

返回类型：void*

参数：size_t  size

含义：malloc向内存申请一块连续的空间，空间的大小是size_t size，单位是字节。然后返回开辟空间的指针。

size_t 是sizeof的返回类型，在64位中是unsigned long int，在32位中是unsigned int。

函数说明：

        1.如果开辟成功，返回一个指向开辟好的空间的指针（地址）。

        2.如果开辟失败，返回NULL空指针，因此malloc一定要检查是否开辟成功。

        3.返回类型是void*,所以malloc并不知道开辟空间的类型，要使用者来决定。

        4.malloc（0）C语言标void*准并没有指定，取决于编译器的看法。事实上，正常人都不会去开辟0个字节的空间。        

#include <stdlib.h>
void free（void* ptr）

 对于free：

返回类型：void

参数类型：void*

含义：释放掉动态内存函数函数开辟的空间，空间的地址为ptr。返回一个void类型的数据。

函数说明：

        1.如果参数ptr指向的空间不是动态内存函数开辟的，那么free的函数行为是未定义的，可能导致程序崩溃。

        2.如果ptr是NULL指针，那么函数什么事都不做。

举个栗子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int num = 5;
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (ptr == NULL)//判断ptr是否为空指针，如果是空指针，说明malloc没有开辟空间成功
		return 1;
	else
	{
		//执行我想要的操作
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//是否有必要？
	return 0;
}

问题来了：

       1. free(ptr);

        2.ptr = NULL;

        这两部分是否有必要执行？

答：

        有必要执行，如果free(ptr)不执行的话，那么malloc开辟的空间一直被我占用着，不会返回给操作系统，假如我写的一个程序要多次使用malloc函数的话，但是我又不free，那么操作系统的内存会被我耗干净或者激发操作系统的内存保护。

        另外，ptr也有必要置为NULL，此时虽然ptr指向的空间被我们free了，但是ptr的地址我们还记得呀，万一此时有人想用ptr，那就是在非法访问操作系统的空间（此时ptr指向的空间已经不属于我了）

看实例：   

int main()
{
	while (1)
	{
		int* a = (int*)malloc(40);
	}
	return 0;
}

        我们观察内存的使用情况：

当程序没有运行时：

程序运行后： 

 很明显，内存泄漏的问题很重。因此很有必要free（ptr）.

看看开辟空间失败的案例：

int main()
{
	int* ptr = (int*)malloc(UINT_MAX/2);
	if (ptr == NULL)
	{
		printf("开辟失败");
	}
	else
	{
		printf("开辟成功");
	}
	return 0;
}

结果：

 结论：

        1.malloc开辟空间不一定成功，因为malloc开辟的是连续的内存空间，当开辟的内存空间太大了，可能会导致开辟不成功，所以开辟空间之后，需要判断一下是否开辟空间成功了，如果不成功，malloc会返回NULL。

        2.开辟空间的函数（malloc realloc calloc）必须要和free配套使用，正所谓有借有还，再借不难。开辟的空间使用完之后，一定要还回去，这样才不会造成内存泄漏。

        3.free释放的空间一定要是动态开辟的空间，而且必须完全释放掉，不能够free释放之后再去free释放一次，也不能只释放一部分动态开辟的内存空间。

2.2calloc函数

#include <stdlib.h>
void* calloc (size_t num, size_t size);

返回类型：void*

函数参数：size_t num  、size_t size

函数含义：为num个大小为size的元素申请一块空间，并且把空间里面的每一个字节初始化为0，返回的指针为开辟空间的第一个元素的地址

举个例子：

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL == p)
	{
		//开辟不成功，返回NULL
	}
	else
	{
		//执行我想要的操作
	}
	free(p);
	p = NULL;
	return 0;
}

        malloc和calloc的区别只在与calloc会在返回地址之前把空间内每个字节都初始化为0，其他的使用方式相同。

动态开辟函数和free函数一定要成对出现，但是成对出现也不一定保证释放了动态开辟的空间。

例如：

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL == p)
	{
		//开辟不成功，返回NULL
	}
	else
	{
		//执行我想要的操作
		return 1;//执行我想要的操作后，直接返回了，free并不会执行
	}
	free(p);
	p = NULL;
	return 0;
}

因此一定要保证free能够完全释放掉所动态开辟的空间。

2.3realloc函数

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

函数含义：

        将动态开辟的空间更改为size个字节，该空间的地址是ptr,函数返回的是realloc开辟内存的地址，这个地址可以是ptr，也可以是其他。

如果ptr是空指针，realloc仅仅分配size个字节的内容，并且返回指向该内存块的指针

realloc(NULL,40) == malloc(40)

如果size为0，realloc释放掉ptr指向的内存块

realloc(ptr,o)      ==     free(ptr)

如果堆中剩余的内存不足以分配size个字节，返回空指针，并且原块保持不变。

2.4realloc函数使用的两种情况

如图：成功开辟空间的两种方式

 

realloc使用场景：

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//业务处理
	}
	else
	{
		exit(EXIT_FAILURE);//具体实现的定义错误
	}
	//扩展容量
	//代码1
	ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)

	//代码2
	int* p = NULL;
	p = realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
		p = NULL;//防止有人用p，造成非法访问
	}
	//业务处理
	free(ptr);
	return 0;
}

        这里如果使用代码1的话，假如realloc开辟空间失败那么返回NULL，ptr就被赋值成NULL，那么malloc开辟的空间都会失去。因此我们在使用动态开辟的函数都需要考虑能不能开辟成功的问题，避免逻辑上的漏洞。

3.总结常见的动态内存错误问题

3.1对NULL指针的解引用操作

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

解析：

        如果malloc开辟空间失败，返回NULL，此时 p=NULL,那么再对p解引用，就会造成内存泄漏，换言之，不能对NULL指针进行解引用操作。

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

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));//开辟40个字节的空间
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)//i--> 0 1 2 3 ....9 10
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
}
int main()
{
	test();
	return 0;
}

解析：

        malloc开辟了10个int类型的空间，但是当i=10的时候，访问的空间是操作系统的，会造成非法访问，可能会导致程序崩溃。

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

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

解析：

        a是局部变量，局部变量是再栈区上创建的，栈区上的数据，入栈的时候创建，出栈的时候销毁。但是free只能释放到堆区上的数据，现在你要free掉栈区上的数据，编译器也不知道怎么做，只能报错。

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

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

解析：

        malloc开辟的空间的指针是p，按理说你free释放的时候需要找到指针p，但是现在p++了，你去free的就不是p原来的指向的地方了，也就是只是释放了一部分，但是对于free来说，它只认识p啊，因此也可能造成程序崩溃。

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

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

解析：

        free以经释放过一次了，释放掉的空间已经是返回操作系统了，此时你再通过free去释放p，那就是再释放操作系统的空间，属于非法访问的，可能造成程序崩溃。

        因此，重复释放也会造成程序崩溃

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

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

解析：

        对于动态开辟的空间忘记free会造成内存泄漏（上述有讲过。看2.1）

总结：对于动态开辟的空间，一定要释放，并且正确的释放，这是一个优秀的程序员必备的。

4.几个经典的笔试题（取自《高质量的C\C++编程》）

4.1题目1

//题目1：请问Test的运行结果
void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

int main()
{
    Test();
    return 0;
}

解析：

 更改代码，修改错误：

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;
}

int main()
{
	Test();
	return 0;
}

解析：

4.2题目2

//题目2：请问Test的运行结果
char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

int main()
{
	Test();
	return 0;
}

解析：这是一个返回栈空间地址的问题

 更改代码，修改错误：

char* GetMemory(void)
{
	static char p[] = "hello world";//static修饰的是静态变量，存在静态区，不会出栈销毁
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

再看看如下代码是否正确（重要！！！好好看！！！）

//代码1：完全正确
int  test()
{
	int a = 10;//a确实出栈销毁了
	return a;
}
int main()
{
	int ret = test();
	printf("%d", ret);
	return 0;
}

//代码2：错误，返回栈空间地址问题，如同问题2
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* ret = test();
	printf("%d", *ret);
	return 0;
}

解析：

4.3题目3

//题目3：请问Test的运行结果
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;//加上被注释的这两句就没有问题了。
}

int main()
{
	Test();
	return 0;
}

4.4题目4

//题目四：请问Test的运行结果
void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}
int main()
{
	Test();
	return 0;
}

解析：

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

直接看图片：

 C/C++程序的内存分配有如下的几个区：

        1.栈区：在执行函数时，函数内部的局部变量（函数包括main函数）在栈区上创建，函数执行结束的时候，这些创建的局部变量会被释放，栈区主要存放的是为了运行函数而创建的局部变量，函数参数，返回数据，返回地址。

        2.堆区：堆区的空间一般是由程序员分配和释放（malloc free calloc realloc ,这四个函数），如果程序员不释放，程序结束的时候，会由操作系统回收，分配的方式类似链表。

        3.数据段（静态区）：存放全局变量，静态变量（static），静态数据，当程序执行结束的时候，由系统释放空间这些数据所占用的空间。

        4.代码段：存放函数体（类成员函数和全部变量）的二进制代码

        理解：在栈区创建的变量，进入栈区的时候创建，除了栈区（作用域）的时候就销毁，但是被static修饰的变量会存在静态区。静态区上的数据会直到程序结束的时候才会销毁。   

6. 柔性数组

        前言：柔性数组的概念在C99标准中存在的，在C99标准中，结构体的最后一个变量允许是长度未指定的数组，这个数组，我们成为柔性数组。这个成员叫做结构体的柔性数组成员。

不妨来创建几个含有柔性数组的结构体：

看代码：

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;



typedef struct sb_type
{
	int i;
	int a[];//柔性数组成员
}type_b;

int main()
{
printf("%d", sizeof(type_a));//结构体的大小是4，意味着柔性数组的大小没有被放进结构体（type_a）中
	return 0;
}

        上述柔性数组有两种声明方式 int a[ ] 和 int a[0],这两种声明方式都是可行的，但是有的编辑器只能识别其中的一种方式。

        通过调试，我们发现，上述两个结构体的大小都是4个字节。柔性数组因为没有指明具体的长度，因此，长度不计算在结构体内。

1.柔性数组的特点：

        1.结构体中的柔性数组成员前面必须至少有一个其他类型的成员（因为柔心数组的大小未指定，因此结构体前面必须有一个大小明确的成员）

        2.sizeof返回这种结构体大小的时候，不包括柔性数组的大小。

        3.包含柔性数组成员的结构体用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大 小，以适应柔性数组的预期大小。（malloc开辟的空间不仅仅要存的下柔性数组，还要存的下柔性数组前面的成员变量，因此malloc开辟的空间一定比柔性数组的空间大）（malloc之后也能用realloc去调整柔性数组的大小）

2.柔性数组的使用

看代码：

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;


int main()
{
	//代码1
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));//malloc的时候要把结构体所有的成员都申请空间
	//业务处理
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);
	p = NULL;
	return 0;
}

        这样的话，柔性数组成员a就获得了100个int类型的元素的空间。

3.柔性数组的优势

看代码：

//代码2
typedef struct st_type
{
	int i;
	int* p_a;//是柔性我想开辟的柔性数组的空间的地址
}type_a;


int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	if (p == NULL)
	{
		return;
	}

	p->i = 100;
	int ps = (int*)malloc(p->i * sizeof(int));//这块被开辟的空间给柔性数组
	if (ps == NULL)
	{
		return;
	}
	p->p_a = ps;
	//业务处理
	for ( int i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;

	return 0;
}

        代码2，也能够malloc出结构体种的柔性数组，只不过要malloc两次。

代码2和上述的代码1可以完成相同的功能，但是代码1有两个好处：

        1.方便内存释放

     如果我们的代码是在一个给别人用的函数中，我们在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，       

         所以你 不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

      2.由于与访问速度

        连续的内存有利于提高访问速度，也有利于减少内存碎片。

7.总结

1.动态开辟的空间，使用完之后，一定要记得free掉，并且每次开辟空间的时候，要去判断是够开辟成功。

2.理解C\C++程序内存开辟的数据存在哪些区域上的，是堆区？栈区？静态区？