目录

一.前言

二.动态内存函数

1.malloc和free

2.calloc函数

3. realloc函数(动态内存空间调整函数)

情形一：扩容时，原内存地址处可以容纳调整后的动态内存

情形二：扩容时，原内存地址无法容纳调整后的动态内存

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

四.柔性数组

柔性数组的优点：

代码段1(柔性数组实现动态数组) 

代码段2 (利用结构成员指针实现变长数组)

五.关于结构体成员访问的知识补充

---

一.前言

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

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

但是上述的开辟空间的方式有两个特点：
1. 开辟的空间大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配，也就是说程序运行时，内存的分配已经完成了。
然而，有时候我们需要申请的对象的内存空间的大小要在程序运行的时候才能确定下来，那上述编译时开辟空间的方式就不能满足我们的使用需求了。
于是，C语言提供了动态内存管理函数。

二.动态内存函数

1.malloc和free

malloc函数首部：void* malloc (size_t size);

这个函数向内存的堆区申请一块连续可用的空间，并返回指向这块空间首地址的指针。
 

---

1.如果内存开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
函数返回值的类型是 void* ，函数调用者可以根据实际需求将返回值转换转换成某种类型的地址并将其存放到一个对应类型的指针变量中。(该地址在其指向的内存空间被释放前不能丢失，否则会造成内存泄漏)

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

free函数首部：void free (void* ptr);
free函数用来释放动态开辟的内存(释放掉ptr指向的地址处后一段连续的动态内存)。(不能用于释放非动态开辟的内存)
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。
3.malloc和free都声明在 stdlib.h 头文件中。

4.malloc，calloc，realloc开辟的空间都由free函数来释放

基本应用示例：

    int num = 0;
    scanf("%d", &num);
    int* ptr = NULL;
    ptr = (int*)malloc(num*sizeof(int));
    if(NULL != ptr)  //判断ptr指针是否为空
    {
        //使用该空间
     }
    free(ptr);       //释放ptr所指向的动态内存
    ptr = NULL;      
    return 0;

注意：

1.指针变量接收malloc的返回值后一定要判断一下其是否为空指针以确定堆区内存是否申请成功。

2.堆区内存使用完毕后一定要用free函数对其进行释放，并将指向该内存的指针变量赋空

3.ptr的值在后续使用中不要被修改，不然动态内存的维护和释放会变得很麻烦(ptr相当于是堆区数组的标识名一样的存在)

2.calloc函数

calloc函数首部：void* calloc (size_t num, size_t size);
1.函数的功能是为 num 个大小为 size 的元素开辟一块连续的空间，并且把空间的每个字节初始化为0。
2.与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0。
举个例子：

int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
    //使用空间
}
free(p);
p = NULL;

所以如果我们对申请的内存空间的内容要求初始化，那么可以使用calloc函数来完成任务

该函数的使用注意事项与malloc基本相同。 

3. realloc函数(动态内存空间调整函数)

函数首部：void* realloc (void* ptr, size_t size);

函数功能：

1.ptr 是要调整的内存地址(必须指向动态申请的堆区空间)
2.size 调整之后新大小
3.返回值为调整之后的内存起始位置。
4.这个函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

5.realloc在调整内存空间(增大调整)的时候存在两种情况：

情形一：扩容时，原内存地址处可以容纳调整后的动态内存

该情形下要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化

情形二：扩容时，原内存地址无法容纳调整后的动态内存

有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

基于上述两种可能情况的分析可以得知：realloc函数使用时，其返回值可能有三种情况

1.内存空间调整失败：返回原空间地址(原空间大小和内容不变)

2.内存空间调整成功：返回原空间地址

3.内存空间调整成功：返回新空间地址

函数调用示例：

    int *ptr = (int*)malloc(100);
    if(ptr != NULL)
    {
        //业务处理
    }
    else
    {
        exit(EXIT_FAILURE);
    }
//扩展容量

    int*p = NULL;
    p = realloc(ptr, 1000);
    if(p != NULL)
    {
        ptr = p;
    }
    //业务处理
    free(ptr);
    return 0;

注意：

realloc的返回值一定要先用一个中间变量来接收，判断该变量不为空指针后再将新地址赋给维护动态内存的ptr指针.如果realloc的返回值直接赋给ptr，那么realloc执行失败时返回空指针会导致原动态内存丢失泄漏。

动态开辟的空间使用完后一定要释放，并且正确释放，忘记释放不再使用的动态开辟的空间会造成内存泄漏.(内存泄漏指向操作系统申请的动态内存不再使用(或因地址丢失而无法使用)，而不释放归还给操作系统，导致该段内存不被占有程序使用的同时也无法被其他程序使用)

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

C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。栈区的特点是在上面创建的变量出了作用域就销毁(作用域用代码段的花括号表示)
2. 堆区（heap）：动态内存函数申请的就是堆区上的内存。
3. 数据段（静态区）（static）存放全局变量、静态数据。数据段的特点是在上面创建的变量，直到程序结束才销毁。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码 

四.柔性数组

 柔性数组是定义在结构体中的数组，其大小由动态内存分配来决定

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;

 有些编译器会报错无法编译可以改成：

typedef struct st_type
{
    int i;
    int a[];//柔性数组成员
}type_a;

关键点：

1.结构中的柔性数组成员前面必须至少一个其他成员(这些其他成员决定其类型大小)。
2.sizeof(type_a)返回值是除柔性数组外其他成员所占的内存(考虑内存对齐)。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于
sizeof(type_a)，以适应柔性数组的预期大小.

实例：

typedef struct st_type
{
    int i;
    int a[0];                  //柔性数组成员
}type_a;

printf("%d\n", sizeof(type_a));//输出的是4


int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理

free(p);

含柔性数组的结构体的成员内存分布(包括柔性数组成员)遵循内存对齐规则。

柔性数组的优点：

代码段1(柔性数组实现动态数组) 

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int))
free(p);
p=NULL;

 

代码段2 (利用结构成员指针实现变长数组)

typedef struct st_type
{
    int i;
    int *p_a;
}type_a;
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));      堆区上的数组用堆区上的结构体来维护
free(p->p_a);                                  释放时必须先释放数组再释放结构体，否则会导致数 
                                               组的地址丢失而造成内存泄漏
p->p_a = NULL;                                            
free(p); 
p = NULL;

 

上述两种动态数组的定义方式的主要差别在于：

1.代码段1的方法只需要一次动态内存分配而代码段2的方法则需要两次动态内存分配。多次动态内存分配会导致堆区上的被占用空间的分布变得零散，内存碎片增多，内存利用率降低。而且不连续的内存分布会让寻址效率有所降低。

 2.代码段2中的方法在使用完数组后要进行两次动态内存释放，并且结构体和其维护的数组两者必须先释放数组再释放结构体，因此代码段2的方法编码隐患更多。

五.关于结构体成员访问的知识补充

 内容参考来自大神陈晧的一篇博客C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell

阅读小笔记:

所谓变量，其实是内存地址的一个抽像名字罢了。在静态编译的程序中，所有的变量名都会在编译时被转成内存地址.

现给出一个代码段：

struct test
{
    int i;
    short c;
    char *p;
};
int main()
{
    struct test *pt=NULL;
    return 0;
}

启动调试运行代码：

调试过程中我们在监视窗口观察一下&(pt->i),&(pt->c),&(pt->p)

可以看到(64位机器下)

&(pt->i)=0x0000000000000000;

&(pt->c)=0x0000000000000004;

&(pt->p)=0x0000000000000008;

如果把&(pt->i),&(pt->c),&(pt->p)换种写法，写成&((*pt).i),&((*pt).c),&((*pt).p)结果也是一样的：

&((*pt).i)=0x0000000000000000;

&((*pt).c)=0x0000000000000004;

&((*pt).p)=0x0000000000000008;

那么上面的0x00，0x04和0x08是怎么产生的呢？

---

这就涉及到对结构体成员访问操作符的更深层次的理解了：

当我们创建一个结构类型时，C的编译器会保存该结构类型中各成员相对于结构体实例(假设存在)首地址的偏移量(遵循内存对齐原则)，当我们访问该结构体某成员时其实就是对 (该结构体首地址 + 某成员偏移量)这个地址值进行解引用。

---

在上述案例中pt中存放了NULL(也就是0)

当我们使用结构体成员访问操作符时：

比如 pt->c 这句代码实质上相当于 *(pt + c的成员偏移量)

那么 &(pt->c)实质上就相当于(pt+c的成员偏移量)，而pt为0，c的成员偏移量为4

这就是&((*pt).c)=0x0000000000000004结果的来源，另外两个也是同理(i的成员偏移量为0，p的成员偏移量为8)

该知识点来整理自大神陈晧的一篇博客C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell