【(C语言进阶)------动态内存管理】
本章重点
一、动态内存函数的介绍
malloc
free
calloc
realloc
二、常见的动态内存错误
三、柔性数组
一、动态内存函数的介绍
malloc
free
calloc
realloc
以上函数的声明都在 stdlib.h 头文件中
malloc--向内存申请一块连续可用的空间，并返回指向这块空间的指针
void* malloc ( size_t size );
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
free---专门是用来做动态内存的释放和回收
void free ( void* ptr );
int main()
{
//动态申请空间
int* p = (int*)malloc(40);
if (p == NULL)
{
perror(malloc);
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
//释放空间
free(p);
p = NULL;
return 0;
}
注意:
当我们不free释放动态申请的内存的时候
如果程序结束，动态申请的内存由操作系统自动回收
但是如果程序不结束，动态内存是不会自动回收的，就会形成内存泄露的问题
calloc
void* calloc (size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
int main()
{
//申请10个整形的空间
int* p = (int*)calloc(40,sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p+i) = i;
}
free(p);
p = NULL;
return 0;
} 
realloc
void* realloc (void* ptr, size_t size);
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc在调整内存空间的是存在两种情况：
1.原有空间之后有足够大的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
2.原有空间之后没有足够大的空间，在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址(原来的空间就会被realloc自动free)。
注意
如果内存没有找到合适的空间,那么reallloc函数会返回一个NULL,并且指向原来空间的指针会被销毁,因此使用realloc函数需要先判断返回的指针是否为NULL,然后再与原来的指针替换
int main()
{
//申请10个整形的空间
int* p = (int*)calloc(40,sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p+i) = i;
}
//空间不够，希望能放20个元素，考虑扩容
int* prt = NULL;//先用空指针来接收
prt = realloc(p, 80);
if (prt != NULL)
{
p = prt;
}
//不再使用，就释放
free(p);
p = NULL;
return 0;
} 
realoc函数额外开辟出的空间（连续开辟出来的）
二、常见的动态内存错误
1.对NULL指针的解引用操作--error
解决办法：对malloc函数的返回值进行判断
void test()
{
int* p = (int*)malloc(INT_MAX / 4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}2.对动态开辟空间的越界访问--error
解决办法：对内存边界要检查
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.对非动态开辟内存使用free释放
void test()
{
int a = 10;
int* p = &a;
free(p);//error
}4.使用free释放一块动态开辟内存的一部分
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置--error
}5.对同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放--error
}6.动态开辟内存忘记释放（内存泄漏）
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
//使用
if (1)
return;
//动态开辟的内存也没释放
free(p);
p = NULL;
}
int main()
{
test();
while (1);
}接下来介绍几个经典有关动态内存的笔试题：
题目1
void GetMemory(char* p)//函数传递形参,内存重新开辟空间,出函数就销毁
{
p = (char*)malloc(100);//内存泄漏(申请的空间没有free)
}
void Test(void)
{
char* str = NULL;
GetMemory(str); //函数传递形参，str指向的空间不发生变化，仍为NULL
strcpy(str, "hello world");//对NULL解引用,程序崩溃
printf(str);
}
----------------------error修改后的代码
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str); //传址调用
strcpy(str, "hello world");
printf(str);
free(str); //主动销毁
str = NULL;
}题目2
char* GetMemory(void)
{
char p[] = "hello world";
return p; //出该函数就是野指针
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
----------------------error题目3
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");//free释放之后,str就是野指针,对野指针操作,程序崩溃
printf(str);
}
}
----------------------errorC / C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。(存储常量字符串的地区)
实际上普通的局部变量是在 栈区 分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被 static 修饰的变量存放在 数据段（静态区） ，数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。
三、柔性数组
1.柔性数组的特点：
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是42. 柔性数组的使用 ：
typedef struct S1
{
int num;
double d;
int a[0];//柔性数组成员
}S1;
int main()
{
printf("%d\n", sizeof(S1));//输出的是16
S1* pf = (S1*)malloc(sizeof(S1) + 40);//申请内存空间
if (pf == NULL)
{
perror("malloc");
return 1;
}
pf->num = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
pf->a[i] = i;
}
S1* tum = (S1*)realloc(pf, sizeof(S1) + 80);//扩容
if (tum == NULL)
{
perror("realloc");
return 1;
}
else
{
pf = tum;
}
for (i = 0; i <20; i++)
{
pf->a[i] = i;
}
for (i = 0; i < 20; i++)
{
printf("%d ", pf->a[i]);
}
free(pf);//释放pf指向的空间，但是free不会将pf置为空指针(需要自己置空)
pf = NULL;
return 0;
}3.柔性数组的优势
与下面这段代码相比较柔性数组的有两个好处：
1.方便内存释放 (内存是连续申请的)
2.有利于访问速度 (连续的内存有益于提高访问速度，也有益于减少内存碎片)
typedef struct S4
{
int num;
int* arr;
}S4;
int main()
{
printf("%d\n", sizeof(S4));//8
S4* pf = (S4*)malloc(sizeof(S4));
if (pf == NULL)
{
perror("malloc\n");
return 1;
}
//第二次为arr 单独申请内存空间
pf->arr = (int*)malloc(40);
if (pf->arr == NULL)
{
//如果第二次申请失败了，那第一次申请的空间就指向空了，因此需要将指针置为NULL
free(pf);
pf = NULL;
return 1;
}
//使用
........
//释放 (分两次释放)
free(pf->arr);
pf->arr = NULL;
free(pf);
pf = NULL;
return 0;
}以上就是动态内存管理的整个介绍，希望对学习C语言的小伙伴有所帮助.