C语言--动态分配内存

爱编程的小枫@

已于 2023-11-18 15:18:33 修改

阅读量125

点赞数

分类专栏： C语言文章标签： c语言开发语言

于 2023-11-18 15:14:12 首次发布

本文链接：https://blog.csdn.net/a9437578h/article/details/134254741

版权

C语言专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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

5.动态内存开辟，忘记释放（内存泄露）

一、解释

C语言的动态内存管理是指在程序运行时，根据需要动态地分配和释放内存空间。这种方式允许程序员在运行时根据实际情况决定内存的使用，而不是在编译时确定。

二、动态分配内存函数

1.free函数

free()函数：该函数用于释放之前通过malloc()、calloc()或realloc()分配的内存。

void free(void *ptr)

2.malloc函数

声明

malloc()函数：该函数用于在堆上分配指定字节数的未初始化内存。

void *malloc(size_t size)

它返回一个指向被分配内存的指针，如果内存分配成功，否则返回NULL。

举例

#define _CRT_SECURE_NO_WARNINGS  1
#include <stdlib.h> // 包含 malloc 和 free 函数  
  
int main() {  
    int* p = (int*)malloc(40); // 分配40个字节的内存  
    if (p == NULL) { // 检查内存是否成功分配  
        printf("Memory allocation failed.\n");  
        return 1; // 如果失败，返回错误代码1  
    }  
      
    // 使用内存...  
    // 例如，将10个整数存储在分配的内存中：  
    for (int i = 0; i < 10; i++) {  
        *(p + i) = i;  
    }  
      
    // ... 使用完之后释放内存  
    free(p);  
    return 0;  
}

3.calloc函数

声明

calloc()函数：该函数用于在堆上分配指定数量的特定类型的未初始化内存。

void *calloc(size_t num, size_t size)

它返回一个指向被分配内存的指针，如果内存分配成功，否则返回NULL。

举例

#define _CRT_SECURE_NO_WARNINGS  1
#include<callobj.h>//包含calloc
#include<string.h>//strerror
#include<errno.h>//errno
int main()
{
	int* p = (int*)calloc(10, sizeof(int));//分配10个，每个大小为int
	if (p == NULL)//判断是否分配失败
	{
		printf("%s\n", strerror(errno));//失败，打印错误信息
		return 1;//直接返回，1
	}
	int i = 0;
	for (i = 0; i < 10; i++)//打印全是零，说明该函数分配内存的同时进行了初始化
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

3. realloc函数

声明

realloc()函数：该函数用于改变已分配内存的大小。

void *realloc(void *ptr, size_t new_size)

它返回一个指向被重新分配内存的指针，如果内存重新分配成功，否则返回NULL。

举例

#define _CRT_SECURE_NO_WARNINGS  1
#include<malloc.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//扩容
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
	}
	//使用
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i+1;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

realloca函数分配空间的两种情况

情况一、

情况二、

三、动态分配内存常见问题

1.对空指针解引用

#define _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	*p = 20;

	printf("%d\n", *p);
	free(p);
	p = NULL;
	return 0;
}

如果代码中，没有if判定是否为空，可能会存在一个潜在的危险。mallo函数分配空间的成功与否，我们并不能直接知道。若分配空间失败，p会是一个空指针，接下来对p的解引用赋值会出现错误。

正确的做法是：加一个if判断语句，若空间分配失败，直接返回1；若成功，执行解引用操作。

2.对动态内存空间的越界访问

#define _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//方式
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		p[i] = i;//*(p+i)
	}
	free(p);
	p = NULL;
	return 0;
}

上述代码中，malloc函数只分配了40个字节的空间，但for循环赋值却要用44个字节，所以造成对动态内存空间的越界访问，程序崩溃。

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

int mian()
{
	int a = 10;
	int* p = &a;
	free(p);//会导致程序崩溃
	p = NULL;
	return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<errno.h>

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//方式
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
         p++;    
	}
	   
	free(p);
	p = NULL;

	free(p);
	p = NULL;
	return 0;
}

此段代码一眼看去，仿佛并没有什么问题。深究一看，问题出在p++处。malloc函数空间开辟成功后，返回该空间的起始地址。而在后续的for循环中，p所存储的地址在不断向后移动。导致free只释放了一部分动态开辟的空间。

5.动态内存开辟，忘记释放（内存泄露）

int* test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return p;
	}
	return p;


}
int main()
{
	int* ret = test();
	return 0;
}

忘记释放内存，会导致内存空间无法再被使用，导致空间浪费。