博客

0.目录

1.摘要



2.为什么存在动态内存管理



3.动态内存函数



3.1 malloc



3.2 free



3.3 calloc



3.4 realloc



4.常见的动态内存错误



5.几个经典笔试题



6.参考文献

1. 摘要

本文主要详解C语言中的动态内存分配

2. 为什么存在动态内存管理

我们先来看一段变量的声明：

double x = 1.000000;
char str[] = "abcdef";

好的，上述变量的声明有何特点呢？

请思考一下，我的朋友。

对，没错，不管是双精度浮点数 x 还是字符数组str，它们都是临时变量，所以当我们为其开辟内存的时候，都是在栈区上进行的。那么既然是在栈区上进行开辟的，那么对应的就被称为

自动变量

，也叫

局部作用变量

，特点是进入作用域，系统为这个变量自动分配内存空间；离开作用域时，系统自动为其销毁内存空间。

还有什么特点？

太棒了，就是如你所说的那样，无论是x还是str，它们所占的内存大小都是由系统自动进行分配的，double为8个byte，str数组为7个byte（包含‘\0’）。而且对于数组而言，我们在声明时就必须指定它的大小；创建局部作用变量之后，我们人为就无法改变它们的大小了。

那么你先在应该已经悟出了为什么会存在

动态内存分配

这一操作了吧，我的朋友。

有的时候，只有当程序运行的时候，我们才能知道我们需要开辟多大的内存空间，而事先无法知晓。那就试试动态内存分配吧。

别担心，我来教你。

3. 动态内存函数

函数是C语言的基本单元，为了实现动态内存分配，我们就需要调用C语言库中的动态内存函数。

动态内存函数能为我们在

堆区

开辟内存。

所引用的头文件为

<stdlib.h>


3.1 malloc

void *malloc( size_t size );

malloc函数的功能就是在静态区分配一块内存块给我们的程序

参数：内存大小（字节）

返回值：

1. 开辟成功，返回指向开辟好的内存空间的指针，类型为void*，使用者根据实际情况，能在使用时将其强制类型转换成任意类型的指针
2. 开辟失败，返回空指针NULL，因此使用malloc时，一定要对返回值进行检查
3. 如果size是0，这是C标准未定义的，取决于编译器

3.2 free

void free( void *memblock );

free用来释放动态开辟的内存

1. 如果memblock指针指向的空间不是动态内存开辟的，这是未定义的
2. 如果memblock指针是NULL，则free什么事也不会做

例如，我们想动态开辟一块10个int类型大小的空间，因该遵循以下流程：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if(p != NULL)
	{
		//...你的操作...
	}
	free(p);
	p = NULL;
	return 0;
}

3.3 calloc

void *calloc( size_t num, size_t size );

calloc函数也是用来动态分配内存的，但与malloc存在两大区别：

1. 参数：需要传入两个参数，第一个参数为开辟内存单元的个数，第二个参数为每个内存单元的大小
2. calloc在返回地址前把申请到的所有内存空间的每个字节初始化为0，而malloc没有这步初始化操作

那让我们来看一下calloc的初始化，对以下代码进行调试：

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

调试结果如图一：

可见，40个字节的值被初始化成了0

3.4 realloc

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

动态内存分配的一大特点就是，能在内存不够用，或者内存开辟得太大的时候，对于开辟内存的大小进行灵活的调整，即对于一个指针指向的内存进行重新的分配

参数：

1. memblock是要调整的内存的地址
2. size是调整之后的内存的大小（byte）

返回值：

1. 调整后指向新的内存的地址的指针
2. realloc在调整内存的基础上，会将原来内存中的数据迁移到新的内存上
3. 如果调整失败或者size=0且memblock不为NULL，返回NULL

realloc调整内存有2种情况：

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

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

那么realloc是怎么处理这两种情况的呢？请看图二：

情况一：要拓展内存，直接在原有内存后面追加空间，原来的数据不发生改变

情况二：原有内存后面没有足够的空间，拓展方法是：指针指向一块新的足够大的内存空间，并将原来的数据复制到这块空间上去。这样返回的就是一个新的地址。

总结

：所以在使用realloc的时候，建议用一个临时指针tmpptr来接收realloc的返回值，如果tmpptr不为NULL，那么就可以安心地用ptr去接收tmpptr了

4. 常见的动态内存错误

1. 对NULL的解引用操作

void test()
{
	int* ptr = (int*)malloc(100);
	//如果此时开辟失败，ptr为NULL
	*ptr = 4;
	free(ptr);
}

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);
	p = NULL;
}

3. 对非动态内存开辟的空间free

void test()
{
	int a = 0;
	int* pa = &a;
	free(a);
}

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

void test()
{
	int* ptr = (int*)malloc(100);
	ptr++;
	free(ptr);
}

5. 对同一块空间多次free

void test()
{
	int* ptr = (int*)malloc(100);
	free(ptr);
	free(ptr);
}

5. 几个经典笔试题

题目一：

void GetMemory(char* p) 
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
//请问运行Test 函数会有什么样的结果？

题目二：

char* GetMemory(void) 
{
	char p[] = "hello world"; 
	return p;
}
void Test(void) {
	char* str = NULL; 
	str = GetMemory(); 
	printf(str);
}
//请问运行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);
}
//请问运行Test 函数会有什么样的结果？

题目四：

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello"); 
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
//请问运行Test 函数会有什么样的结果？

参考答案

题目一：

GetMemory函数传参为值传递，Test函数中的str依旧为NULL，无法向NULL地址处拷贝字符串，printf也无法打印

malloc后未free

题目二：

数组p在栈区上创建，出了GetMemory函数p就销毁，str其实就成了野指针

题目三：

malloc后未free，str未置成NULL

题目四：

str动态分配的内存已经被释放了，但下面还敢继续使用str，这是一个野指针问题

6. 参考文献

1.《C Primer Plus》第6版 p396 – 401

注：有关C/C++的内存开辟以及柔性数组的概念，我会单开2篇博客进行讲解，欢迎大家阅读！