动态内存管理

C进阶:动态内存管理

  • 动态内存管理
  • 前言
  • 为什么要存在动态内存分配
  • 动态内存函数介绍
    • 动态内存函数开辟空间
    • malloc和free
    • calloc
    • realloc
  • 常见的动态内存错误
    • 对空指针的解引用操作
    • 对动态开辟内存空间的越界访问
    • 对非动态开辟内存使用free释放
    • 使用free释放一块动态开辟内存的一部分
    • 对同一块动态内存多次释放
    • 动态开辟内存忘记释放(内存泄漏)
  • C/C++程序的内存开辟
  • 柔性数组
    • 柔性数组定义
    • 柔性数组的特点
    • 柔型数组优势

动态内存管理

前言

动态内存管理是非常重要的,以后会用到的地方非常多,主要重点内容有:

  1. 动态内存函数的介绍
  • malloc
  • free
  • calloc
  • realloc
  1. 常见的动态内存错误
  2. C/C++动态内存开辟
  3. 柔性数组

为什么要存在动态内存分配

像我们这样平时使用的变量定义,数组定义等等,这些有以下特点:

  1. 空间开辟大小是固定的。
  2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。

但是对于空间的需求,很多时候我们并不知道要使用多少,所以就引入了动态内存开辟。

动态内存函数介绍

动态内存函数开辟空间

首先要记住一点:动态内存函数开辟的空间是在堆区上

动态内存管理_第1张图片

malloc和free

我们先看函数信息:

动态内存管理_第2张图片

大致意思就是告诉malloc你要开辟多大内存空间,malloc给你申请,返回一个void*的指针,指向为你开辟好的空间地址。如果开辟失败则返回空指针。

我们可以用一个简单例子来说明malloc用法:

#include 
#include 
#include 

int main()
{
	//开辟10个整型大小
	int* p = (int*)malloc(10 * sizeof(int));
	//如果开辟失败打印错误信息
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
        return 1;
	}
	//打印开辟好的空间内容
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	return 0;
}

我们可以看一下打印结果:动态内存管理_第3张图片

这样写看起来是没有任何问题的,开辟好的空间里面都是随机值并且很好的打印了出来。但实际上这样是有问题的,这就要引出free函数了

我们看函数信息:

动态内存管理_第4张图片

在我们malloc向操作系统申请空间在使用完之后我们最好还给操作系统,虽然从结果上来看,这个程序结束后空间也会被操作系统回收,那如果你写出的代码出现了问题一直不结束呢?所以我们最好手动释放空间,这就要用到free这个函数了,只要将地址传给free即可。除此之外我们还有一个需要注意的点:

动态内存管理_第5张图片

可以看到即使我们free之后,p的值没有改变,注意这时候我们已经将空间还给操作系统了,但是p还是指向那个地址,这时候如果有胆子比较大的通过p去访问那块空间就出大问题了,这时候就是非法访问了,所以在free之后我们还需要手动将p置为空指针才行。

以上就是我们对malloc和free的分析,所以上面那个例子的正确代码应该是:

动态内存管理_第6张图片

以上就是malloc和free的用法。

我们可以总结一下:

1.malloc为你申请一定大小的空间,成功则返回void*的指针,失败则返回空指针;

2.由于返回的是void*,所以需要强制转换一下才可以使用;

3.在使用完之后要使用free手动释放空间;

4.释放后要将旧指针置为空指针;

calloc

calloc和malloc其实差不多但是有几点区别:

我们先看函数信息:

动态内存管理_第7张图片

和malloc类似,但是我们要告诉calloc我们需要几个元素,每个元素大小是多少,函数参数这点和malloc有些区别,我们通过代码来举例如何使用:

#include 
#include 
#include 

int main()
{
	//开辟10个整型空间
	int* p = (int*)calloc(10, sizeof(int));
	//如果开辟失败打印错误信息
	if (p == NULL)
	{
		perror("calloc");
        return 1;
	}
	//打印空间的内容
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

输出:动态内存管理_第8张图片

诶,可以看到结果似乎并不是随机值,而是全部初始化为了0,没错,这也是calloc和malloc的区别,这时候我们就可以总结一下了:

动态内存管理_第9张图片

以上就是calloc的介绍。

realloc

上面我们只是介绍了如何动态开辟空间,但是如果空间不够大或者过大需要调整怎么办呢,这就要用到realloc来调整了,

函数信息有些复杂,我们先简单看函数参数:

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

解释一下就是将需要调整的空间地址传过去,然后是需要调整的大小。调整成功则返回void*的指针,失败返回NULL。

但需要注意的是我们不能用旧的指针p直接接受返回值,什么意思呢?举个例子:

动态内存管理_第10张图片

可以看到编译器也是给报警告了,这就是拿原来的指针直接接受,可以会造成原来空间没有回收,造成内存泄漏问题。为什么会出现这种情况呢?

我们要明白realloc的工作原理:

动态内存管理_第11张图片

看懂这里我想你就明白了为什么不能直接用旧的指针来接收了,

  • 第一种原因是:原来空间没有回收,会造成内存泄漏
  • 第二种原因是:如果没有扩容成功,返回一个空指针原来的数据也搞丢了

所以我们只能用一个新的指针来接受realloc的返回值,然后判断不为再空赋给p,并且将p置为空指针。

正确代码如下:

#include 
#include 
#include 

int main()
{
	//开辟10个整型空间
	int* p = (int*)calloc(10, sizeof(int));
	//如果开辟失败打印错误信息
	if (p == NULL)
	{
		perror("calloc");
        return 1;
	}
	//假设我们要扩容到20个整型空间
	int* str = (int*)realloc(p, 20 * sizeof(int));
	if (str != NULL)
	{
		p = str;
		str = NULL;
	}
	free(p);
	p = NULL;
	return 0;
}

关于realloc还有一点需要补充的是如果给realloc传递的为NULL,那么此时realloc的功能和malloc一样。

例如:

int* p=(int* )realloc(NULL,10*sizeof(int));

此时realloc相当于malloc。

常见的动态内存错误

对空指针的解引用操作

#include 
#include 
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	//这里一定要注意判断是否是空指针
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

这时候没有加判断是否为空的话,下面使用就有可能是野指针。

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

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
    //越界访问
	for (int i = 0; i < 100; i++)
	{
		*(p + i) = 0;
	}
	free(p);
	p = NULL;
	return 0;
}

这段代码看起来一气呵成,但是你要是运行的话,就出问题了,你会发现程序直接挂了,卡死关都关不掉,点好几下才可以。因为这里是越界访问了,注意我们malloc开辟的空间大小是100字节,而不是100个整型的大小。

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

#include 
int main()
{
	int a = 10;
	int* p=&a;
	free(p);
	return 0;
}

动态内存管理_第12张图片

对于这样非动态开辟的内存空间是不可以用free来释放的,可以看到这个程序挂的还是挺严重的,直接卡死退都退不出去。

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

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 25; i++)
	{
		*p = i;
		p++;//注意p移动了
	}
	free(p);
	p = NULL;
	return 0;
}

注意到p是已经移动了,我们后面free释放的是一部分空间。像这种动态内存开辟的函数你使用出问题了,大部分都是上面那种程序直接卡死的情况。

对同一块动态内存多次释放

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

原因是p已经是释放过一次了,这时候p还是指向原来的位置,这时候已经是野指针了,再去free就会出问题

所以我们在第一次free时一定要将p置为空指针,下面如果再次free就不会出问题,free的参数为NULL什么事都不做。

动态开辟内存忘记释放(内存泄漏)

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

这种情况一定要注意,这时候如果你发现问题,想释放都来不及了,因为在函数里面的参数一出函数就销毁了,你找都找不到那个地址。

为了避免这种情况我们要注意的有:

malloc和free一定要成对出现使用,

如果在函数内部使用且不想在函数内部释放要写清楚注释:

例如:

//test函数内部进行了malloc操作,返回了开辟空间的起始地址,记得释放
int* test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
	return p;
}
int main()
{
	int* ptr=test();
	free(ptr);
	ptr = NULL;
	while (1);
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

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

动态内存管理_第13张图片

  1. 栈区(stack):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
  2. 堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分配方式类似于链表。
  3. 数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放。
  4. 代码段:存放函数体(类成员函数和全局函数)的二进制代码。

柔性数组

柔性数组定义

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

typedef struct st_type
{
int i;
int a[];//柔性数组成员--有些编译器可能要写成a[0]
}type_a;  

柔性数组的特点

  • 柔性数组成员的前面至少有一个成员
  • sizeof计算结构体大小不包括柔型数组的大小
  • 包含柔型数组的结构应该用malloc动态分配内存

使用举例:

struct S
{
	int n;
	char arr[];//柔型数组成员
};
int main()
{
	//柔型数组空间的开辟
	struct S* pc = (struct S*)malloc(sizeof(int) + 10 * sizeof(char));
	if (pc == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", pc->arr[i]);
	}
	//释放空间
	free(pc);
	pc = NULL;
	return 0;
}

柔型数组优势

以上面例子,我们使用另外一种方式同样可以达到效果,如:

struct S
{
	int n;
	char* str;
};

int main()
{
	struct S* pc = (struct S*)malloc(sizeof(struct S));
	if (pc == NULL)
	{
		perror("malloc->pc");
		return 1;
	}
	char* ps = (char*)malloc(10 * sizeof(char));
	if (ps == NULL)
	{
		perror("malloc->ps");
		return 1;
	}
	pc->str = ps;
	ps = NULL;
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", *(pc->str + i));
	}
	free(ps);
	ps = NULL;
	free(pc);c
	pc = NULL;
	return 0;
}

我们来对比一下两种方法

动态内存管理_第14张图片

首先一点就是两次malloc在实际场景中肯定要比使用一次容易出错,你可能忘记释放空间或者多种情况。

其次还有一个概念叫做内存碎片,动态内存管理_第15张图片

所以我们可以总结一下,

  • 第一个好处是:方便内存释放
    如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。

  • 第二个好处是:这样有利于访问速度

    连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)

你可能感兴趣的:(C语言进阶,c++,c语言)