动态内存管理

一、malloc、free、calloc和realloc

包含头文件

1.malloc

void* malloc(size_t size);
这个函数向内存申请一块连续可用的空间，并返回这块空间的指着。

• 开辟成功返回空间指针；失败返回NULL需检查。
• 返回值类型是void*,具体使用时决定。

2.free

void free(void* ptr);
free函数用来释放动态开辟的内存。

• 如果参数ptr指向的空间不是动态开辟的，那free函数的行为是无意义的。
• 如果参数ptr是空指针，则函数什么事都不做。

int main()
{
	int num = 0;
	scanf("%d",&num);
	int arr[num] = {0};
	int* ptr = NULL;
	ptr = (int*)malloc(num*sizeof(int));
	if(NULL!=ptr)
	{
		int i = 0;
		for(i=0;i<num;i++)
		{
			*(ptr+i)=0;//不用使ptr++指针位置发生变化
		}
	}
	free(ptr);
	ptr = NULL;//free后仅仅是没有了使用权限，ptr将变成野指针，置空会安全
	return 0;
}

3.calloc

void* calloc(size_t num,size_t size);
函数的功能是为num个大小为szie的元素开辟一块空间，并且把空间的每个字节初始化为0。（与malloc相似）

4.realloc

void* realloc(void* ptr,size_t size);
可以做到对动态开辟内存大小的调整。

• ptr是要调整的内存地址，size是调整之后的新大小；返回值为调整之后的内存起始地址。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
• 存在两种情况：
  1.原有空间有足够大的空间；
  2.原有空间没有足够大的空间
• 当是情况2的时候，原有空间之后没有足够多的空间时，会在堆空间上另找一个合适大小的连续空间来使用，函数返回的是一个新的内存地址。（或者申请失败返回NULL）

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 = realooc(ptr,1000);
	if(p != NULL)
		ptr = p;
	//业务处理...
	free(ptr);
	return 0;	
}

上面例子中，代码1是错误的代码2是正确的，由于realloc还可能存在申请空间失败的情况，直接放到ptr中，ptr仍指向原来的内存区域，但被更新为NULL，这意味着你失去了对原始内存区域的引用，会导致内存泄漏。

二、常见的动态内存错误

1.对NULL指针的解引用操作

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

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);//?
 }

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

切记动态开辟的空间一定要正确释放。

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

题目1

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

**运行结果：**程序崩溃。
存在问题：

• 在GetMemory函数中，p是一个指针的副本，对它的修改不会影响到Test函数中的str指针；这种方式是按值传递的，出了函数体后局部变量就会被销毁。
• 在GetMemory函数中没有检查malloc是否成功分配了内存。
• 如果成功分配没有free释放内存会导致内存泄漏。
  修改：
  1.通过指针的指针

#include 
#include 
#include 

void GetMemory(char **p)//指向str的是一级指针，指向&str的是二级指针
{
    *p = (char *)malloc(100);
    if (*p == NULL)
    {
        perror("malloc");
        return 1;
    }
}

void Test(void)
{
    char *str = NULL;
    GetMemory(&str);//传址
    strcpy(str, "hello world");
    printf("%s\n", str);
    free(str);
    str = NULL;
}

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

2.返回分配的内存

char* GetMemory(void)
{
    char *p = (char *)malloc(100);
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    return p;//返回p赋给str
}

void Test(void)
{
    char *str = GetMemory();
    strcpy(str, "hello world");
    printf("%s\n", 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);
}

**运行结果：**垃圾值、程序崩溃或产生其他不可预测的行为。
错误分析：

• 返回局部变量的地址，当GetMemory函数执行完毕后，o所占用的内存可能已经被释放或者被其他数据覆盖。以至于尝试访问p的地址出现未定义的结果。
  修改方式：
  1.使用malloc分配内存
  2.使用静态数组

题目3

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

在 Test 函数中，str 指向的内存被 free 释放后，str 变成了一个悬空指针，即它仍然指向原来的内存地址，但该内存已经不再属于程序。
在 free(str); 之后，尝试对 str 进行任何操作都是不安全的，因为原来的内存可能已经被操作系统或其他程序重新分配。所以应该在其后记得加上"str=NULL;"语句。

四、总结C/C++中程序内存区域划分

1.栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
链接: 函数栈帧的创建和销毁
2.堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。（动态分配）
3.数据段/静态区（static）：存放全局变量、静态数据。程序结束后由系统释放。
4.代码段：存放函数体（类成员函数和全局函数）的二进制代码。