动态内存管理的常见问题

问题目录

• 为什么要进行动态内存管理？
• 一.动态内存管理函数
•  1.malloc
•  2.calloc
•  3.realloc
•  4.free
• 二.动态内存管理的常见问题
•   1.对空指针进行解引用操作
•   2.对动态开辟的空间越界访问
•   3.对非动态开辟的内存空间free
•   4.使用free释放动态内存开辟的一部分
•   5.对一块动态开辟的空间多次释放
•   6.动态开辟的内存空间忘记释放(内存泄漏)
• 三.面试题目
• 四.总结

---

为什么要进行动态内存管理？

因为内存太宝贵。如果全部是静止内存不能释放，对于小的程序可以运行完毕。但是对于大的程序，还没运行完，内存就要被占用完，此时就要发生内存泄露。

给定一个占用内存可变大小的变量（假设是数组的长度len），给该变量通过函数动态分配内存后，分配内存的大小是根据数组的长度len决定的，假定用户输入len的大小是5，系统就会动态的给该数组分配长度为5的内存，该段代码运行结束后，系统调用free()函数释放分配的内存，然后接着运行剩下的程序。换句话说，动态分配内存可以根据需要去申请内存，用完后就还回去，让需要的程序用。
 

一、动态内存分配管理函数

1.malloc

1.函数的返回类型为空指针类型，如果为开辟成功那么返回NULL

 2.函数开辟的空间十载内存中的堆区开辟的，会在整个程序结束后自动销毁。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p == NULL)
	{
		perror("malloc");
	}
	else
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 5; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

 注意：开辟不成功返回错误信息

2.calloc

1.第一个参数表示开辟元素的个数，第二个参数表示每个元素的大小（单位：字节）
2.calloc与malloc大体相同，区别为calloc申请的空间会被初始化为0.

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(5,sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
	}
	else
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 5; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

 

 3.relloc

1. 第一个参数为空指针类型是一块动态开辟空间的地址，第二个参数是重新调整后动态开辟空间的大小,这个函数可以对之前开辟的空间重新调整可大可小

2.在用realloc函数扩容的时候，若原空间后面的空间充足，那么新开辟的空间就是与原空间挨着的后面的空间

3.在用realloc函数扩容的时候，若原空间后面的空间不充足，那么会找到一块新的空间大小为扩容后的大小，并且会将原空间的内容拷贝到新空间中，还会释放掉原空间。

int main()
{
	int* ptr = malloc(40);
	int* p = realloc(ptr, 80);
	return 0;
}

 

int main()
{
	int* ptr = malloc(40);
	int* p = realloc(ptr, 10);
	return 0;
}

4.free

1.作用是将动态开辟的空间释放

2.我们在动态开辟内存空间后，并且使用完后，要及时free释放空间，避免造成内存泄漏。我们在动态开辟内存空间后，并且使用完后，要及时free释放空间，避免造成内存泄漏。

二.动态内存分配管理的常见问题

1.对空指针进行解引用操作

void test()
{
	int* p = (int*)malloc(sizeof(int) * INT_MAX);
	*p = 20;
	free(p);
}

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

void test()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
}

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

void test()
{
	int a = 10;
	free(&a);
}

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

void test()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*p = i;
			p++;
		}
	}
	free(p);
	p = NULL;
}

5.对一块动态开辟的空间多次释放

void test()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	free(p);
	//...
	//...
	//...
	//...
	free(p);
}

6.动态开辟的内存空间忘记释放(内存泄漏)

void test()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
	}
	
}

注意 ：以上就是动态内存开辟过程中容易出错的六个地方，在你写代码的时候要注意！！！

三.面试题目

1.

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

（1）对p开辟的空间，并不会带回函数test中，所以str一直指向的都是NULL，在调用strcpy时，会造成对空指针解引用。
（2）对动态开辟的空间没有free

正确做法：

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	if (str != NULL)
	{
		strcpy(str, "hello world");
		printf(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);
}

这是一种常见的错误就是，返回栈空间地址，函数返回了p指针p但是指针p指向的内容已被销毁。

正确做法：

char* GetMemory(void)
{
	static char p[] = "hello world";
	return p;
}
int main()
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
	return 0;
}

3.

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

1，主要问题是没有释放动态开辟的内存空间造成内存泄漏。
2，还有一个小问题就是在使用str时没有提前判断str是否为空指针

正确做法：

void GetMemory2(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test2(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	if (str != NULL)
	{
		strcpy(str, "hello");
		printf(str);
	}
	free(str);
	str = NULL;
}

4.

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

1，这道题的问题所在是，释放掉str所指向的空间后，没有将str指向空指针。这造成了调用strcpy函数时形成了非法访问。

正确做法：

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

以上四道题目都出自《高质量的C/C++编程》这本书中。

---

 总结

对动态内存管理一定要好好掌握，让自己的空间合适再合适，一起拿到合适的offer！！！