C语言——动态内存管理

void* malloc (size_t size);

这个函数向内存申请一块大小为size字节的连续可用的空间，并返回指向这块空间的指针

• 如果开辟成功，则返回一个指向这块空间的指针
• 如果开辟失败，则返回一个空指针（NULL），因此我们一定要对malloc的返回值作有效性的判断
• 返回值为void *，因此当我们用指针变量接受这个返回值时，我们要将这个返回值强制转换为需要的类型
• 如果参数size为0，malloc的行为是标准未定义的，

例如：

#include<stdio.h>
#include<stdlib.h>
int main()
{
    //向内存申请40个字节的空间，并将返回的指针强制转换成int*型，并将其赋予指针nums
    int *nums = (int*)malloc(sizeof(int) * 10);	

    //检验返回值的有效性
    if (nums == NULL)
    {
        perror("malloc");
        return 1;
    }

    //循环打印nums指向空间的值
    for (int i = 0; i < 10; i++)
        printf("%d\n", *(nums + i));
    
    free(nums);
    nums = NULL;
    
    return 0;
}

output:

-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451

• 这说明，malloc申请到空间后，是不会对该空间初始化的

需要注意：凡是动态申请的内存，除非整个程序结束，申请的内存是不会主动归还给系统的，为了避免内存泄漏，我们应该使用函数free来将申请的内存释放

void free (void* ptr);

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

• 如果参数``ptr指向的空间不是动态开辟的，那free`函数的行为是未定义的
• 如果参数ptr是NULL指针，则函数什么事都不做
• 正常释放后，ptr指向不明，称为野指针，因此，应该置为空(NULL)

例如：

#include<stdio.h>
#include<stdlib.h>

int main()
{
    //向内存申请40个字节的空间，并将返回的指针强制转换成int*型，并将其赋予指针nums
    int *nums = (int*)malloc(sizeof(int) * 10);	

    //检验返回值的有效性
    if (nums == NULL)
    {
        perror("malloc");
        return 1;
    }

    free(nums);	//释放ptr所指向的动态内存
    nums = NULL;	//将野指针置空
    
    return 0;
}

void* calloc (size_t num, size_t size);

• 函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0
• 与函数malloc的区别只在于calloc会在返回指针之前把申请的空间的每个字节初始化为0

例如：

##include<stdio.h>
#include<stdlib.h>
int main()
{    
	//申请10个大小为4的空间，并让指针nums指向它
    int* nums = (int*)calloc(10, sizeof(int));

    //判断返回值的有效性
    if(nums == NULL)
    {
        perror("calloc");
        return 1;
    }

    //打印nums指向空间的元素
    for (int i = 0; i < 10; i++)
        printf("%d\n", *(nums + i));
    
    
    free(nums);
    nums = NULL;
    
    return 0;
}

output:

0
0
0
0
0
0
0
0
0
0

所谓的动态内存管理，“内存管理”我们好像已经会了，那这个“动”又是怎么做到的呢？我们前面所学的malloc, calloc好像并不能让申请的内存动起来呀。

要想实现对内存的增加或减小，就需要我们的函数realloc：

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

• ptr是要调整的内存地址

  • 如果ptr不为空，那么就会修改ptr所指向空间的大小
  • 如果ptr为空，那么就和malloc的功能相似，会直接返回一个指向大小为size字节空间的指针

• size为调整之后的大小

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

• 扩容后的空间不会被初始化

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

• ealloc在调整内存空间时存在两种情况：

  • 情况一：原有空间之后有足够大的空间，那么就在原有的地方增容，并返回原来的起始地址

  

  • 情况二：原有空间之后没有足够大的空间，那么就在合适的地方重新开辟一块大小为size的空间，将原来空间的数据拷贝到新空间，再释放掉原来的空间，最后再返回新空间的起始地址

    

• 如果调整失败，就会返回空指针，为了考虑到这种情况，我们应该避免以下的代码：

//error example

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* nums = (int*)malloc(10 * sizeof(int));
	if (nums == NULL)
	{
		perror("malloc");
		return 1;
	}

    //如果开辟失败，那么nums就成了空指针，前面nums管理的40个字节的空间就找不到了，这样就造成了内存泄漏
	nums = (int*)realloc(nums, 20 * sizeof(int));
	if (nums == NULL)
	{
		perror("realloc");
		return 1;
	}
	
	free(nums);
	nums = NULL;

	return 0;
}

• 正确的方式应该是这样的：

//right example

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* nums = (int*)malloc(10 * sizeof(int));
	if (nums == NULL)
	{
		perror("malloc");
		return 1;
	}

    //先用一个中间变量temp接受
	int* temp = (int*)realloc(nums, 20 * sizeof(int));
	if (temp == NULL)
	{
		perror("realloc");
		return 1;
	}
	
    //当temp有效时，再用nums接受
    nums = temp;
    
	free(nums);
	nums = NULL;

	return 0;
}

最后，再对realloc的具体使用举个例子：

#include<stdio.h>
#include<stdlib.h>

int main()
{
    //先动态开辟40个字节的内存
	int* nums = (int*)malloc(10 * sizeof(int));
	if (nums == NULL)
	{
		perror("malloc");
		return 1;
	}

    //将这块空间初始化为0
	memset(nums, 0, 10 * sizeof(int));

    //将这块空间扩容到60个字节，并先用中间变量temp接受
	int* temp = (int*)realloc(nums, 15 * sizeof(int));
	if (temp == NULL)
	{
		perror("realloc");
		return 1;
	}

    //确定temp有效后再用nums指向temp
	nums = temp;

    //打印扩容后空间的数据
	for (int i = 0; i < 15; i++)
	{
		printf("%d\n", nums[i]);
	}
	
    //释放内存
	free(nums);
	nums = NULL;

	return 0;
}

output：

0
0
0
0
0
0
0
0
0
0
-842150451
-842150451
-842150451
-842150451
-842150451