探索动态内存开辟的奥秘

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

个人主页：秋邱'博客

所属栏目：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：