C语言进阶——动态内存管理

目录

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

二.   动态内存函数

1.malloc

2.free

3.calloc

4.realloc 

三.   常见的动态内存错误

四.   内存开辟

五.   柔性数组

---

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

在此之前，我们为数组开配空间都是这样的

int nums[10]={0};

但这样会有很大的局限性

1. 空间开辟大小是固定的。

2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。

这时候就只能试试动态内存开辟了

---

---

二.   动态内存函数

1.malloc

说白了，就是在堆区开辟一块大小为size字节的连续的空间 ，然后以指针形式返回这块空间的地址

而具体在使用时，例如开辟一个大小为5的整形数组，往往遵循以下的形式

int* nums=(int*)malloc(5*sizeof(int));

可以看到，由于malloc函数返回的是void*指针类型，所以我们需要进行强制类型转换，而后面的size，我们采用的是开辟数组大小*类型大小，这样也更容易理解

而当开辟失败时（可能是开辟空间过大，堆区没有这么大的空间了），则返回NULL指针，因此，在使用malloc开辟空间后，在使用这个数组之前，我们需要先进行检查

int* nums=(int*)malloc(5*sizeof(int));
if(nums==NULL)
{
    printf("malloc fail\n");
    exit(-1);
}

而还有一点就是，若是size的大小为0，这种情况是未定义的，如何处理取决于编译器，因此我们要避免这种情况发生。

而若是想要使用这块空间，就像数组的数组名一样使用

int main()
{
	int* nums = (int*)malloc(5 * sizeof(int));
    if(nums==NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
	for (int i = 0; i < 5; i++)
	{
		nums[i] = i + 1;
		*(nums + i) = i + 1;
	}
	return 0;
}

这两种方法都是可以的。

同样，我们可以开辟一个指针数组，进而可以模拟一个二维数组

int main()
{
	int** nums = (int**)malloc(5 * sizeof(int*));
	if (nums == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	for (int i = 0; i < 5; i++)
	{
		nums[i] = (int*)malloc(5 * sizeof(int));
		if (nums[i] == NULL)
		{
			printf("malloc fail\n");
			exit(-1);
		}
	}
	return 0;
}

当然，这只是模拟的二维数组，每个一维数组在内存中都不是连续的，而真正的二维数组是连续的，但两者在使用上并没有太多差异

---

2.free

都已经开辟了，在不使用的情况下如果不把他释放就会一直占用堆区的空间，导致内存泄漏，而动态开辟的空间又不会随着域的结束而结束，这时我们便需要一个函数来主动释放

就是把动态开辟返回的指针作为参数，就能实现释放了

有两点需要注意： 

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

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

---

3.calloc

说简单点，与malloc只是有写法上的不同，是将大小和类型大小分开传参

还有一点不同的是，会将所有元素初始化为0，其他特性与malloc类似

---

4.realloc 

说简单点，就是将开辟的空间扩增或者缩小

缩小没啥好说的，原地缩就行了，而扩增时，若是原本空间后面没有足够的空间，便会另找一块足够大的空间来存储。而若是没有这块空间，也一样会返回NULL，因此，我们不能拿原数组直接来接受返回值，而是定义一个新的指针来接受，并将其赋给原数组，若是NULL就不赋给原数组，因此也不会对原数组产生影响

而在赋给原数组后，若是重新开辟的空间（而不是在原数组的基础上扩容），那么原数组原本所在的位置会被自动销毁。

int main()
{
	int* nums = (int*)calloc(5 , sizeof(int));
	int* p = (int*)realloc(nums, 100 * sizeof(int));
	if (p == NULL)
	{
		printf("realloc fail\n");
		exit(-1);
	}
	nums = p;
	return 0;
}

大概就是这样

而我们也可以在调试时监视一下

   可以看到，这就是重新开辟空间的情况

---

---

三.   常见的动态内存错误

对NULL指针的解引用操作

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

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

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

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

动态开辟内存忘记释放（内存泄漏）
 

上述错误我们在上面或多或少的都提到了，这就就不展开讲了（懒）

---

---

四.   内存开辟

 1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

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

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

---

---

五.   柔性数组

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

typedef struct st_type
{
    int i;
    int a[];
}type_a;

就像上面这样

特点

1.结构中的柔性数组成员前面必须至少一个其他成员。

2.sizeof 返回的这种结构大小不包括柔性数组的内存。

typedef struct st_type
{
    int i;
    int a[0];
}type_a;
printf("%d\n", sizeof(type_a));

例如上面的代码，所打印出来的结果便是4 

3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
for(int i=0; i<100; i++)
{
    p->a[i] = i;
}
free(p);
p=NULL;

我们也可以像下面这样写 

type_a *p = (type_a *)malloc(sizeof(type_a));
p->p_a = (int *)malloc(p->i*sizeof(int));
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;

 而这两种方法的差别在于第一种动态开辟了一次，在内存中是连续的，而且只需要释放一次

而第二种方法动态开辟了两次，在内存中不一定是连续的，而且需要释放两次

而第一种方法较佳，有两个好处

方便内存释放

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

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

连续的内存有益于提高访问速度，也有益于减少内存碎片。（内存碎片指的就是内存中难以被使用的小分区）