【C语言进阶】动态内存管理

最新推荐文章于 2024-09-10 20:34:55 发布

爱编程的小马.

最新推荐文章于 2024-09-10 20:34:55 发布

阅读量1k

点赞数 27

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

本文链接：https://blog.csdn.net/s1mplewo/article/details/138188480

版权

C语言进阶专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细介绍了C/C++中的动态内存分配，包括malloc,free,calloc,realloc函数的用法和原理，以及柔性数组的概念、特点和优势。通过实例演示了如何使用这些工具进行内存管理和释放。

摘要由CSDN通过智能技术生成

📚作者简介：爱编程的小马，正在学习C/C++，Linux及MySQL..

📚以后会将数据结构收录为一个系列，敬请期待

● 本期内容会给大家讲解如何开辟动态内存空间，以及c/c++内存是如何分配的，最后还会给大家讲解柔性数组

1. 为什么存在动态内存分配

我们已经掌握的内存开辟的方式有

int a = 20; //开辟4个字节的空间存储a
char arr[20] ={0} ;//连续开辟20个字节的空间

这些开辟方式都是在栈区上开辟的，但是这种开辟方式有两个问题：

1、空间开辟的大小是固定的

2、数组在声明的时候，必须指定开辟的长度

那么动态内存开辟就比较简单了，顾名思义，就是你开辟内存是不固定的，不够了可以加，多了可以减，这就是动态内存开辟

2. 动态内存开辟的要学习的四个函数

2.1 malloc函数

C语言给程序员提供了一个动态内存开辟的函数malloc

void *malloc( size_t size );

这个函数会向内存申请一块连续可用的空间，并返回指向这块空间的指针

● 如果开辟成功，会返回这块空间的起始地址

● 如果开辟失败，会返回空指针NULL，所以在使用时一定要对malloc返回值进行检查

● 返回值类型的void*，具体接收类型由程序员决定

● 如果size是0,这个是标准为定义的，也是没有意义的，具体由编译器决定

2.2 free函数

C语言专门设置了一个函数用于释放动态内存空间

void free( void *memblock );

一定要注意：free函数是用来释放动态开辟的内存空间

● 如果memblock指针指向的不是动态开辟的内存，则free函数的行为是未定义的

● 如果memblock指针指向的是NULL空指针，则free函数什么都不做

我们一起来开辟一块动态内存空间：

#include<stdio.h>
#include<stdlib.h>

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

上述代码的运行结果是：

可以看到malloc函数给我们开辟了一块40个字节的空间，但是打印的全是随机值，说明malloc函数并不会给你初始化那块空间。如果要初始化空间，就需要接下来要介绍的calloc函数可以满足需求。

2.3 calloc函数

C语言给程序员提供了一个动态内存开辟的函数calloc

void *calloc( size_t num, size_t size );

● 这个函数的功能是给num个大小为size元素开辟一块空间，并且把空间初始化为0

● 如果开辟失败，会返回空指针NULL，所以在使用时一定要对calloc返回值进行检查

举个例子：

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

看看这段代码输出的效果：

其实无论是malloc还是calloc，好像只能为我们申请动态内存空间，而不能灵活的调节咱们的动态内存空间，这时候realloc函数就出现了，它可以很好的为我们管理malloc，calloc申请的动态内存空间。

2.4 realloc函数

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

● memblock是要调整的内存地址

● size是调整后的新大小

● 返回调整后的内存地址

● 如果内存不够，realloc函数会在其他地方找一块足够的空间，同时拷贝原内存中数据至新地址，返回这块空间的地址

使用realloc函数：

1、如果原有空间之后有足够大的空间

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//40个字节空间不够，我们要80个字节
	int * ptr = (int *)realloc(p, 60);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	ptr = NULL;
	for (i = 0; i < 15; i++)
	{
		printf("%d\n", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

是如何判断是否原空间之后是否有足够空间呢？看realloc的返回值，如果返回的是和p一样的，说明没有新开辟空间，如图

2、如果原空间没有足够大的空间

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//40个字节空间不够，我们要80个字节
	int * ptr = (int *)realloc(p, 800);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	ptr = NULL;
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

这个时候p和ptr的值不同了，说明会开辟一块新的空间，那我们来看下原来的数据会不会丢了呢？

看看运行结果：

可以看到，原来的内存空间中存放的数据没有丢，而是被realloc拷贝过来了。这就是realloc开辟新空间的操作：

1、拷贝原空间的数据到新空间

2、释放原来的空间

3、返回新空间的起始地址

3. c/c++程序的内存开辟

首先，c/c++的内存分为内核空间区，栈区，堆区，数据段以及代码段。

栈区主要是存放形式参数，局部变量；堆区，主要是动态内存开辟；数据段，主要是存放全局变量和静态数据（static修饰的变量）；代码段主要是存放只读常量以及可执行代码

看这个图片

4.柔性数组

4.1什么是柔性数组

在C99规定中，柔性数组是结构体最后一个元素允许是未知大小的数组，这就叫做柔性数组成员

例如

struct s 
{
	int age;
	int a[];//柔性数组
};
int main()
{
	return 0;
}

柔性数组的特点：

1、结构中柔性数组成员前必须至少有一个其他成员

2、sizeof求结构体大小是不包含柔性数组大小

3、包含柔性数组结构体成员在malloc分配时，应分配的内存大于结构大小，以适应柔性数组大小

#include<stdio.h>
#include<stdlib.h>
struct s 
{
	int i;
	int a[];//柔性数组
};
int main()
{
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 100 * sizeof(int));
	ps->i = 100;
	int j = 0;
	for (j = 0; j < 100; j++)
	{
		ps->a[j] = j; //柔性数组就获得了连续的400个字节的空间
	}
	free(ps);
	ps = NULL;
	return 0;
}

那么其实我同样可以用指针来完成上述代码

#include<stdio.h>
#include<stdlib.h>
struct s
{
	int i;
	int* p;
};

int main()
{
	struct s* ps =(struct s*) malloc(sizeof(struct s));
	ps->i = 100;
	ps->p = (int*)malloc((ps->i) * sizeof(int));
	int j = 0;
	for (j = 0; j < 100; j++)
	{
		ps->p[j] = j; //柔性数组就获得了连续的400个字节的空间
	}
		for (j = 0; j < 100; j++)
	{
		printf("%d ",ps->p[j]); //柔性数组就获得了连续的400个字节的空间
	}
	free(ps->p);
	ps->p = NULL;
	free(ps);
	ps = NULL;
	return 0;
}