一文带你了解动态内存管理

╰半橙微兮° 2023-10-13 17:31 47阅读 0赞

**目录**

动态内存存在的意义

动态内存函数的介绍

malloc和free

calloc

realloc

常见的动态内存错误

对NULL指针解引用操作

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

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

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

对同一块内存多次释放

动态开辟内存忘记释放

经典的笔试题

C/C++程序的内存开辟

柔性数组

柔性数组的特点

柔性数组的使用

柔性数组的优点

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

# 动态内存存在的意义 #

int a = 10;
    int arr[10] = { 0 };

上面变量开辟的空间有两个特点：  
空间开辟的大小是固定的

数组在声明的时候，必须指定数组的长度，它需要的内存在编译时分配

但是，我们有的时候空间的需要大小在程序运行的时候才知道，数组的编译是开辟空间的方式就不能满足了。这时候就需要动态内存开辟了。

# 动态内存函数的介绍 #

## malloc和free ##

void* malloc (size_t size)

![4fbba12905d5450589620b407581feb0.png][]

**malloc函数向内存申请一块连续可用的空间，返回指向这块空间的指针。**

**注意：**  
**如果开辟成功，则返回一个指向这块空间的指针。、**

**如果开辟失败，则返回一个空指针，使用malloc的返回值要做检查**

**返回值的类型是void\*类型，malloc不知道开辟空间的类型，需要使用者自己来决定。**

**如果size为0，malloc的行为是属于标准未定义的**

C语言还提供了另一个函数free，是用来释放动态内存的。

void free (void* ptr)

![3894ff0e7e2847a5a21e81885dd56906.png][]

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

**如果参数ptr指向的不是动态开辟的空间，这种行为是标准未定义的。**

**如果参数ptr是NULL指针，则函数什么事都不会做**

**malloc和free的声明都在stdlib.h中**

举个栗子：

要注意把ptr变为NULL，不然它就是野指针了

#include <stdio.h>
    #include <stdlib.h>
    int main()
    {
    	int arr[10] = { 0 };
    	int* ptr = (int*)malloc(40);
    	if (ptr == NULL)
    		return 1;
    	for (int i = 0; i < 20; i++)
    	{
    		*(ptr + i) = i;
    	}
    	free(ptr); //释放空间
    	ptr = NULL;//把ptr变为NULL，不然他是野指针
    	return 0;
    }

## calloc ##

void* calloc (size_t num, size_t size）

![b8e33a0709d1450285d5a5365720fef6.png][]

**calloc将num个大小为size的元素初始化为0**

**与malloc的区别在于calloc会在返回地址前将申请的空间全部初始化为0**

int main()
    {
    	int* ptr = (int*)calloc(10, sizeof(int));
    	if (ptr == NULL)
    		return 1;
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d\n",*(ptr + i));
    	}
    	free(ptr);
    	ptr = NULL;
    	return 0;
    }

![129302d33d5049b98cd4bfc0b4012486.png][]

## realloc ##

void* realloc (void* ptr, size_t size)

![6ac2dbb8c96047b99663d334bed884b7.png][]

realloc的出现可以让动态内存管理变得更加灵活。有时我们会发现过去申请的空间太小了，又有时觉得太大了。为了合理管理内存，我们一定会对内存的大小进行调整。realloc就可以做做到对动态开辟内存大小地调整。

**ptr是要调整内存地地址**

**size是调整后的大小**

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

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

**realloc在调整原内存空间有两种情况：  
1 原有空间之后有足够大的空间**

**2 原有空间之后没有足够大的空间**

![b2c576e3036d4da28c8ab3ca38fa80b6.png][]

**情况一：要扩展内存的时候就直接在原有内存后面追加空间，原来空间的数据不发生变化。**

**情况二：原有空间之后没有足够的空间时，会在对堆上找另一块空间来使用，函数返回的就是这个新的内存地址。**

**栗子：**

int main()
    {
    	int* p = (int*)malloc(40);
    	if (p == NULL)
    		return 1;
    	for (int i = 0; i < 10; i++)
    	{
    		*(p + i) = i;
    	}
    
    	int* ptr = (int*)realloc(p, 50);
    	if (ptr == NULL)
    		return 1;
    	p = ptr;
    	ptr = NULL;
    	for (int i = 0; i < 20; i++)
    	{
    		printf("%d ", *(p + i));
    	}
    	free(p);
    	p = NULL;
    	return 0;
    }

# 常见的动态内存错误 #

## 对NULL指针解引用操作 ##

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

**这里没有对p进行判断，如果malloc申请空间失败的话，他就会为空指针，对空指针解引用就会出现问题。**

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

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

**观察代码我们发现，当i等于10时，会越界访问，导致不可控的因素。**

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

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

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

void test()
    {
     int *p = (int *)malloc(100);
     p++;
     free(p);//p不再指向动态内存的起始位置
    }

**p指针移动后释放会导致一部分内存无法释放**

## 对同一块内存多次释放 ##

void test()
    {
     int *p = (int *)malloc(100);
     free(p);
     free(p);//重复释放
    }

## 动态开辟内存忘记释放 ##

void test()
    {
     int *p = (int *)malloc(100);
     if(NULL != p)
     {
     *p = 20;
     }
    }
    int main()
    {
     test();
     while(1);
    }

**忘记释放动态开辟的内存这样会导致内存泄露，使这部分内存无法再使用**

# 经典的笔试题 #

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

这段代码里面的str是传值调用，这函数将str重新拷贝了一份，函数接受这个函数就销毁了，str还是NULL，则strcpy不能使用，printf也打印不出

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

这里返回的p是野指针，因为出了函数p开辟的空间就销毁了，p指向的内容是未知的，打印出来的内容也是未知。

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

这里虽然是传址调用，但是到最后它没有将开辟的空间释放掉，导致内存泄露。

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

这里是提前释放了空间，让后面的拷贝的地址后没有地方被他们存放

# C/C++程序的内存开辟 #

![9510abff271248c5912f6aed1036c104.png][]

**内存分配的区域：**

**栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结**

**束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是**

**分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返**

**回地址等。**

**堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。**

**数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。**

**代码段：存放函数体（类成员函数和全局函数）的二进制代码。**

**对于static的解释 ：**

实际上普通的局部变量是在**栈区**分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。

但是被static修饰的变量存放在**数据段（静态区）**，数据段的特点是在上面创建的变量，直到程序

结束才销毁 所以生命周期变长

![eb5e262058c44ef3aa74415f8bc8e2ef.png][]

# 柔性数组 #

**C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。**

struct st_type
    {
     int i;
     int a[0];//柔性数组成员
    };

struct st_type
    {
     int i;
     int a[];//柔性数组成员
    };

有些编译器可以使用第一种方法，有些可以使用第二种方法

## 柔性数组的特点 ##

**结构体中的柔性成员前面至少得有一个其他的成员**

**sizeof求这种结构的大小不会包括柔性数组**

**包括柔性数组成员的结构用malloc进行动态内存分配的时候，分配的内存应该大于结构体的大小，以便适用柔性数组的预期大小**

typedef struct st_type
    {
     int i;
     int a[0];//柔性数组成员
    }type_a;
    printf("%d\n", sizeof(type_a));//输出的是4

## 柔性数组的使用 ##

typedef struct st_type
    {
     int i;
     int a[0];//柔性数组成员
    }type_a;
    
    int i = 0;
    type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
    //业务处理
    p->i = 100;
    for(i=0; i<100; i++)
    {
     p->a[i] = i;
    }
    free(p);

这个柔性数组，相当于获得了100个整型的连续空间

## 柔性数组的优点 ##

上面的代码其实也可以这样设计：

typedef struct st_type
    {
    	int i;
    int* p_a;
    }type_a;
    type_a* p = (type_a*)malloc(sizeof(type_a));
    p->i = 100;
    p->p_a = (int*)malloc(p->i * sizeof(int));
    //业务处理
    for (i = 0; i < 100; i++)
    {
    	p->p_a[i] = i;
    }
    //释放空间
    free(p->p_a);
    p->p_a = NULL;
    free(p);
    p = NULL;

**上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：**

**第一个好处是：方便内存释放**

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给

用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你

不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好

了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

**第二个好处是：这样有利于访问速度.**

连续的内存有益于提高访问速度，也有益于减少内存碎片

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

[4fbba12905d5450589620b407581feb0.png]: https://img-blog.csdnimg.cn/4fbba12905d5450589620b407581feb0.png
[3894ff0e7e2847a5a21e81885dd56906.png]: https://img-blog.csdnimg.cn/3894ff0e7e2847a5a21e81885dd56906.png
[b8e33a0709d1450285d5a5365720fef6.png]: https://img-blog.csdnimg.cn/b8e33a0709d1450285d5a5365720fef6.png
[129302d33d5049b98cd4bfc0b4012486.png]: https://img-blog.csdnimg.cn/129302d33d5049b98cd4bfc0b4012486.png
[6ac2dbb8c96047b99663d334bed884b7.png]: https://img-blog.csdnimg.cn/6ac2dbb8c96047b99663d334bed884b7.png
[b2c576e3036d4da28c8ab3ca38fa80b6.png]: https://img-blog.csdnimg.cn/b2c576e3036d4da28c8ab3ca38fa80b6.png
[9510abff271248c5912f6aed1036c104.png]: https://img-blog.csdnimg.cn/9510abff271248c5912f6aed1036c104.png
[eb5e262058c44ef3aa74415f8bc8e2ef.png]: https://img-blog.csdnimg.cn/eb5e262058c44ef3aa74415f8bc8e2ef.png