动态内存管理的常见问题

深碍√TFBOYSˉ_ 2024-04-06 12:53 58阅读 0赞

## 问题目录 ##

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

--------------------

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

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

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

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

## 1.malloc ##

![af0c31c23931485f87be5b27f9a71922.png][]

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

### ![189dd872fb234589af475c2cbcadddcc.png][] 注意：开辟不成功返回错误信息 ###

## **2.calloc** ##

![d4b7f5e0abb9449482665cb1cf9c19a7.png][]

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

![7d0f411e1fc542ae87b988602af72245.png][]

![d6f664ebf04a427ebf0f9e9389b0a7ee.png][]

##  **3.relloc** ##

![0eb52090e8b1465bb57d66652bb098b8.png][]

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

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

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

![06029b84f58848f49f9f57b69f62cca7.png][]

![c966abd40fab44ed886e745cbff23a31.png][]

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

![d6e3f8645cc64dcf8429f6bc61801cf8.png][]

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

![eb7d6ed772e74b1d9e90e1cfac8ee4d1.png][]

## **4.free** ##

![963fb2ac88ea49f694d6c55c5a78e7ce.png][]

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

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

![a0d11dcf53544c95a10276bf69f4c168.png][]

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

**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！！！**

[Link 1]: https://so.csdn.net/so/search?q=%E5%86%85%E5%AD%98&spm=1001.2101.3001.7020
[af0c31c23931485f87be5b27f9a71922.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/89343223d47b475786f1465cc50c2b12.png
[189dd872fb234589af475c2cbcadddcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/be4a1b7c841a46ad831a48d190b9217e.png
[d4b7f5e0abb9449482665cb1cf9c19a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/8026c3f0522d4703b12e8cdb031e7a74.png
[7d0f411e1fc542ae87b988602af72245.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/742dd95c3712441d867857abed778ee5.png
[d6f664ebf04a427ebf0f9e9389b0a7ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1dbe2c60827e44e7963c07336d93fe12.png
[0eb52090e8b1465bb57d66652bb098b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/62b6b6ae68584b48925dda93336f8aa9.png
[06029b84f58848f49f9f57b69f62cca7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/6b10bdcc0de74af0916cdcbefdd6a81b.png
[c966abd40fab44ed886e745cbff23a31.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/5430c6ed50e540aabbc958f0836a5210.png
[d6e3f8645cc64dcf8429f6bc61801cf8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/f8097b5ca455418b934ade8ad17e3ec0.png
[eb7d6ed772e74b1d9e90e1cfac8ee4d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/db5d74ab891442ef9d94a6c70839b65e.png
[963fb2ac88ea49f694d6c55c5a78e7ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/766fbe62412442ee9f8ee39a96497857.png
[a0d11dcf53544c95a10276bf69f4c168.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/064a9aa568324f19934adf5619f0deb7.png