探索动态内存开辟的奥秘

✨✨欢迎👍👍点赞☕️☕️收藏✍✍评论

个人主页：秋邱'博客

所属栏目：C语言

 

 前言

开始之前，我们先来了解一下C/C++中程序内存区域划分。

在C/C++程序中，内存区域通常被划分为以下几个部分：

1.栈：

• 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等

2.堆：

• 用于动态分配的内存，程序员可以通过malloc、calloc、realloc等函数在堆上动态分配内存空间。
• 堆的分配和释放由程序员手动控制，因此需要注意避免内存泄漏和内存溢出等问题。

3.全局/静态区：

• 用于存储全局变量、静态变量以及常量字符串等。
• 全局变量和静态变量在程序启动时被分配，直到程序结束才被释放。

4.常量区：

• 存储常量字符串等不可修改的数据。

5.代码区

• 存储程序的机器指令，包括函数体的二进制代码等。

---

1.0 静态内存

目前有两个开辟内存的方式

	int a = 0;//在栈空间上开辟四个字节
	char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间

但是上述代码的开辟的空间有个特点：

• 开辟的空间大小是固定。
• 数组空间大小一旦确定就不能更改。

  ---

2.0 动态内存 

有时候我们需要的空间⼤⼩在程序运⾏的时候才能知 道，那数组的编译时开辟空间的⽅式就不能满⾜了。因此，C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。

那么这里就需要用到四个函数，开辟空间的有：malloc、calloc、realloc；释放空间的有：free。

这四个函数需要的头文件都是#include<stdlib.h>

2.1 malloc

函数声明：

void* malloc (size_t size);

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。 

size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。

使用：

如果开辟成功，则返回⼀个指向开辟好空间的指针。

如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。

如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

malloc的使用方法：

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

int main()
{
	int* arr = (int*)malloc(sizeof(int) * 10);
	// 分配一个整数的内存空间
	//void* 需要用类型指针接收，这里选择用int*
	if (arr == NULL)
	{
		perror("malloc fail: ");//打印错误信息
		return 1;//直接返回
	}
	int i = 0;
	for (i = 0; i < 10; i++)//数组赋值
	{
		arr[i] = i;
	}
	for (i = 0; i < 10; i++)//打印数组
	{
		printf("%d ", arr[i]);
	}
	//释放内存
	return 0;
}

输出结果：

2.2 calloc 

函数声明：

void* calloc (size_t num, size_t size);

 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。

与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* num = (int*)calloc(10,sizeof(int));
	if (num == NULL)
	{
		perror("calloc fail: ");//打印错误信息
	    return 1;//直接返回
	}
	//使用

    //内存释放
	return 0;
}

2.3 realloc 

realloc相比malloc和calloc更加灵活，它是在内存不够的时候开辟新的内存。realloc可以做到对动态内存大小的调整。

函数声明：

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

ptr：指向先前用malloc、calloc或realloc分配的内存块的指针，或者，这可以是一个空指针，在这种情况下，一个新的块被分配(好像malloc被调用)。

size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。

 realloc有三种情况：

1.内存足够大不需要realloc额外申请。

2.空间不足

情况一：原有空间之后有⾜够⼤的空间（原地扩容）

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。

情况二：原有空间之后没有足够大的空间（异地扩容）

当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。 

 由于上述的两种情况，realloc函数的使⽤就要注意⼀些。

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr == NULL)
	{
		perror("malloc error");
		return 1;
	}
    //动态内存不够进行扩展容量
    //先将realloc函数的返回值放在p中，不为NULL，在放ptr中
	int* p = realloc(ptr, 1000);
	if (p != NULL)
	{
		perror("realloc error");
		return 1;
	}
	ptr = p;
	//如果直接赋值，realloc开辟失败返回NULL，*ptr就会出现问题
	return 0;
}

很明显，代码1存在问题，若realloc没开辟成功，却将空指针返回给ptr，ptr解引用则会报错。使用代码2，更加合理。 

2.4 free 

free函数⽤来释放动态开辟的内存。这在写代码过程中是很有必要的。

函数声明：

void free (void* ptr);

 ptr表示指向malloc，realloc，callloc开辟的动态空间内存。

使用：

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

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

返回值：

不反回任何值。

    //malloc释放动态内存
    free(arr);//释放函数
    arr = NULL;//将指针置为空

    //calloc释放动态内存
    free(num);
    num = NULL;

    //realloc释放动态内存
    free(ptr);
    ptr = NULL;

    

---

3.0 动态内存常见的错误 

3.1 对空指针解引用

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

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

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

3.3 对⾮动态开辟内存使⽤free释放

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

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

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

忘记释放动态内存空间会造成内存泄漏。

3.5 对同⼀块动态内存多次释放

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

3.6 使⽤free释放⼀块动态开辟内存的⼀部分

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

---

4.0 柔性数组

4.1 什么是柔性数组

在结构体中，最后一个

成员是数组，且数组没有指定大小，这个数组就是柔性数组

struct S1
{
	char c;
	int n;
	int arr[];//柔性数组
};

struct S2
{
	char c;
	int n;
	int arr[0];//柔性数组
};

 s1和s2写法不一样，但这都是柔性数组，有的编译器支持s1有的支持s2。

4.2 柔性数组的特点

• 结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。
• sizeof 返回的这种结构⼤⼩不包括柔性数组的内存。
• 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。

struct S
{
	char c;
	int n;
	int arr[0];//柔性数组
};
int main()
{
	struct s1* p = (struct s1*)malloc(sizeof(struct s1) + 5 * sizeof(int));
	//sizeof(struct s1)是给char c和int n申请的内存空间
    //而5 * sizeof(int)是给柔性数组申请的
    if(p == NULL)
    {
        perror("malloc error");
        return 1;
    }
	printf("%zd", sizeof(struct s1));
	return 0;
}

打印结果：

realloc可以额外申请空间，这就是的数组变得可大可小，这就是柔性数组。

4.3 柔性数组的使用

//代码1

#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int arr[];
};
int main()
{
	struct S* p = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 10);
	if (p == NULL)
	{
		perror("malloc error");
		return 1;
	}
	p->n = 10;//初始化
	for (int i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}
    struct S* ptr = (struct S*)realloc(p, sizeof(struct S) + 10 * sizeof(int));
    //空间不够调整空间
	if (ptr != NULL)
	{
		p = ptr;
	 }
	printf("%d ", p->n);//打印
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p->arr[i]);
	}
    free(p);//释放空间
    p = NULL;
	return 0;
}

4.4 柔性数组的优势

//代码2
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int* arr;
};
int main()
{
	struct S* p = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 5);
	if (p == NULL)
	{
		perror("malloc error");
		return 1;
	}
	p->n = 11;
	for (int i = 0; i < 5; i++)
	{
		p->arr[i] = i;
	}
	printf("%d ", p->n);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p->arr[i]);
	}
	//若空间不够调整空间
	int* ptr = (int*)realloc(p->arr,  10 * sizeof(int));
	if (ptr != NULL)
	{
		p->arr = ptr;
	 }
	//使用...
	//释放空间
	free(p->arr);
	free(p);
	p = NULL;
}

通过对两者的使用和比较，柔性数组更甚一筹。

优势有2：

 1.方便内存释放：在函数给其他人使用时，代码在里面进行了二次分配，并把整个结构体返回给⽤ ⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free。如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给⽤⼾⼀个结构体指针，那么只需要free一次就能释放。

2.利于访问速度：连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你 跑不了要⽤做偏移量的加法来寻址。

---

感谢各位大佬莅临，如有错误欢迎指出，共同学习进步。