C 进阶 — 动态内存管理

主要内容

动态内存函数

malloc
free
calloc
realloc

常见动态内存错误

经典练习

柔性数组

一动态内存函数

之前已介绍的内存开辟方式有

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

上述开辟空间的方式有两个特点

1、空间开辟大小固定

2、数组在声明时，必须指定数组长度，它所需要的内存在编译时分配

有时需要的空间大小在程序运行时才知道，那编译时开辟空间的方式就不能满足需求了

1.1 malloc 和 free

C 提供的动态内存开辟函数

void* malloc (size_t size);

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

如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个 NULL 指针（malloc 的返回值一定要做检查）

返回值类型 void* ，malloc 函数并不知道开辟空间的类型，由调用者自行决定。如果参数 size 为 0 ，malloc 的行为是标准是未定义的，取决于编译器

C 提供的专门用来动态内存释放和回收的函数

void free (void* ptr);

该函数用来释放动态开辟的内存

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

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

如下例

#include <stdio.h>
//malloc 和 free 都声明在 stdlib.h 头文件中
int main()
{//代码 1int num = 0;scanf("%d", &num);//int arr[num] = {0}; //编译报错,表达式必须有常量值//代码 2int* ptr = NULL;ptr = (int*)malloc(num*sizeof(int));if(NULL != ptr) // 判断 ptr 指针是否为空{int i = 0;for(i=0; i<num; i++){*(ptr+i) = i;printf("%d\n", *(ptr + i));}}free(ptr); //释放 ptr 所指向的动态内存ptr = NULL; //避免野指针return 0;
}

1.2 calloc

calloc 函数也用来动态内存分配，原型如下

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为 0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0

#include <stdio.h>
#include <stdlib.h>
int main()
{int *p = (int*)calloc(10, sizeof(int));if(NULL != p){//使用空间}free(p);p = NULL;return 0;
}

如果对申请的内存空间要求初始化，使用 calloc 更方便

1.3 realloc

realloc 对已申请的动态内存的大小做调整，函数原型如下

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

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置

realloc 对内存空间调整存在两种情况

① 原空间后有足够空间，直接在原地址后追加空间，原空间数据不发生变化

② 原空间后没有足够空间，则在堆另找一块大小合适的连续空间使用，返回值是一个新的内存地址

realloc 使用注意

#include <stdio.h>
int main()
{int *ptr = (int*)malloc(100);if (ptr != NULL){//业务处理}  else{exit(EXIT_FAILURE);    }//扩展容量//代码1ptr = (int*)realloc(ptr, 1000);//这样如果申请失败, 则 PTR 指针将会被置 NULL, 无法再重新 realloc//代码2int*p = NULL;p = realloc(ptr, 1000);if(p != NULL){ptr = p;}//业务处理free(ptr);return 0;
}

1.4 内存开辟

C/C++ 程序内存分配的几个区域

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

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

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

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

二常见动态内存错误

2.1 对指针不判 NULL

void test()
{int *p = (int *)malloc(INT_MAX/4);*p = 20;	//若动态内存申请失败, 则 p 值为 NULLfree(p);
}

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

2.3 对非动态内存使用 free 释放

void test()
{int a = 10;int *p = &a;free(p);	//运行中断 debug log - Invalid address specified to RtlValidateHeap
}

2.4 仅释放动态内存的一部分

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

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

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

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

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

不正确释放或忘记释放动态开辟的空间会造成内存泄漏，动态开辟的空间一定要释放，且正确释放

三经典练习

运行 Test 函数会有什么结果

3.1 练习一

void GetMemory(char *p)
{p = (char *)malloc(100);
}
void Test(void)
{char *str = NULL;GetMemory(str); //str 仍是 NULLstrcpy(str, "hello world"); //strcpy assret NULL(core)printf("%s\n", str);
}//修改方法
char* GetMemory()
{return (char *)malloc(100);
}void Test(void)
{char *str = GetMemory();if (str){strcpy(str, "hello world");printf("%s\n", str);}
}

3.2 练习二

char *GetMemory(void)
{char p[] = "hello world";return p;
}void Test(void)
{char *str = NULL;str = GetMemory();printf("%s\n", str);
}

上述程序执行结果, 打印乱码。因为 char p[] = "hello world"; 在栈区申请的内存会在函数调用结束后销毁, 所以 str 指向已被销毁内存的栈区域

修改方法如下，或者将 "hello world" 改为动态内存申请的内容

char *GetMemory(void)
{char* p = "hello world"; //常量字符串return p;
}void Test(void)
{char *str = NULL;str = GetMemory();printf("%s\n", str); //正常打印
}

3.3 练习三

void GetMemory(char **p, int num)
{*p = (char *)malloc(num); //注意这里有解引用操作符
}void Test(void)
{char *str = NULL;GetMemory(&str, 100);strcpy(str, "hello");printf("%s\n", str);
}

打印 hello，因为在 GetMemory 中对入参 char **p 进行了解引用 *p = ,那么就相当于入参是 char *p , 赋值是 p = (char *)malloc(num);

3.4 练习四

void Test(void)
{char *str = (char *) malloc(100);strcpy(str, "hello"); //这里未判 NULLfree(str);//释放动态内存后 str 也未置 NULL, 野指针if(str != NULL) //使用未初始化的 str{strcpy(str, "world");printf("%s\n", str);}
}

打印 world，但有问题（因为 str 指向的是已经被释放了的动态内存空间）

修改如下

void Test(void)
{char *str = (char *) malloc(100);if (str){strcpy(str, "hello");free(str);str = NULL; }//一些其他操作if(str){strcpy(str, "world");printf("%s\n", str);}
}

四柔性数组

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

typedef struct st_type
{int i;int a[0];//柔性数组成员
}type_a;//有些编译器会报错无法编译可以改成
typedef struct st_type
{int i;int a[];//柔性数组成员
}type_a;

4.1 柔性数组特点

结构中的柔性数组成员前面必须至少一个其他成员
sizeof 返回的这种结构大小不包括柔性数组的内存
包含柔性数组成员的结构用 malloc () 函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

//例如
typedef struct st_type
{int i;int a[0]; //柔性数组成员
}type_a;printf("%d\n", sizeof(type_a)); //输出的是 4

4.2 柔性数组使用

//代码一
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{p->a[i] = i;
}
free(p);

这样柔性数组成员 a，相当于获得了 100 个整型元素的连续空间

4.3 柔性数组优势

上述的 type_a 结构也可以设计为

//代码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));//业务处理
for(i=0; i<100; i++)
{p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;

上述代码 1 和代码 2 可以完成同样功能，但代码 1 有两个好处

方便内存释放

若该代码是提供给第三方调用的，那么调用方在 type_a * p 使用完后， free(p); 会导致内存泄漏。故一次性把结构体内存及成员内存分配好，并返回一个结构体指针，调用方一次 free 所有的内存都会被正确释放

有利于访问速度

连续内存有利于提高访问速度和减少内存碎片

4.4 扩展阅读

C 语言结构体里的数组和指针

陈皓老师写的真不错，简单总结如下

#include <stdio.h>
struct str{int len;char s[0];
};struct foo {struct str *a;
};int main(int argc, char** argv) {struct foo f={0};if (f.a->s) {printf( f.a->s);}return 0;
}