目录
为什么要有动态内存分配
int val = 20 ; // 在栈空间上开辟四个字节的连续空间char arr[ 10 ] = { 0 }; // 在栈空间上开辟十 个字节的连续空间
• 空间开辟⼤⼩固定• 数组声明时，必须指定数组的⻓度，长度⼀旦确定了便不能调整
malloc函数
函数原型：void* malloc(size_t size);
作用：向内存申请一块连续可用的内存空间，并返回指向这块内存空间的指针
包含头文件：<stdlib.h>
注意事项：
1、返回的是无类型指针void*，在使用时一定要强制转换为所需要的类型
2、使用完开辟的内存空间后一定要释放空间，如果不释放会造成内存泄漏
3、如果开辟成功，则返回一个指向开辟好空间的指针
4、如果开辟失败，则返回一个NULL指针
5、size的值为0时，它将分配一个大小为0的内存块，并返回一个指向该内存块的指针。但是需要注意的是，这个指针可能是无效的，因为在分配大小为0的内存块时，并不会真正地分配任何内存空间，所以最终情况还是要看编译器的反应
6、动态内存分配相关的函数，它们要操作或者申请的的内存空间属于内存中的堆区
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型（40个字节）的空间
int* p = (int*)malloc(10 * sizeof(int));
//判断内存空间是否非开辟成功
if (p == NULL)
{
perror("malloc"); 如果开辟失败就是用perror函数返回错误信息
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}free函数
函数原型：void free (void* ptr);
作用：对申请的动态内存空间进行释放
包含头文件：<stdlib.h>
注意事项：
1、如果ptr指向的内存空间不是动态开辟的，那free函数的行为是未定义的
2、如果ptr是NULL指针，则函数什么事都不做
3、free仅释放了空间里数据，但空间的地址仍未释放，需要将指向开辟空间地址的指针置为空
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型（40个字节）的空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p); //释放p所指向的动态内存
p = NULL;
return 0;
}
calloc函数
函数原型：void* calloc (size_t num,size_t size);
作用：为num个大小为size的元素开辟一块空间，并把空间的每个字节初始化为0
包含头文件：<stdlib.h>
注意事项：
1、与malloc函数的区别只在于calloc会在返回地址前，将申请的空间中的每个字节都初始化为0
#include <stdio.h>
#include <stdlib.h>
int main()
{
//申请10个整型（40个字节）的空间
int* p = (int*)calloc(10,sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
//使用空间
int i = 0;
/*for (i = 0; i < 10; i++)
{
*(p + i) = i;
}*/
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p); //释放p所指向的动态内存
p = NULL;//free只是释放了空间是空间的地址仍未释放
return 0;
}
realloc函数
函数原型：void* realloc(void* ptr,size_t size);
作用：使动态内存管理更加灵活，对申请的动态内存大小进行调整
包含头文件：<stdlib.h>
注意事项：
1、返回调整后的内存起始地址，ptr指向要调整的内存空间，size为调整后的大小
2、内存空间调整后，原内存中的数据移动到新空间，并释放原空间
3、ralloc在调整内存空间时存在两种情况：原有空间够和空间不够
①原有空间足够（返回地址为旧地址）
②原有空间不够（返回地址为新地址，但原来指向该地址的指针仍然存在）
#include <stdio.h>
#include <stdlib.h>
int main()
{
//malloc申请五个字节的内存空间
int* p = (int*)malloc(5 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
int* ptr = (int*)realloc(p, 400);
if (ptr != NULL) //扩容成功
{
p = ptr; //还是要使用原来的p就把新地址赋值给p
ptr = NULL; //此时ptr为空指针所以将ptr设置为空
}
else //扩容失败报错
{
perror("realloc");
return 1;
}
free(p);
p = NULL;
return 0;
}
关于“int* ptr = (int*)realloc(p, 400);”和“p = ptr;”解释：
进行扩容时，ptr是指向新空间的指针，如果扩容成功的同时我们还想继续使用原来的p指针只需要将ptr所指向的地址赋值给p（虽然被扩容了原来空间不存在了但是p指针指向的地址仍然保留），此时ptr变成空指针了所以要将NULL赋值给ptr，但是注意在赋值结束后不能对ptr进行free操作否则新申请的内存空间就会被释放且ptr和p都会变成野指针
tips：当realloc函数的第一个参数是NULL指针的时候，功能类似于malloc函数
int*p = (int*)realloc(NULL,40); //malloc(40)
常见的动态内存的错误
对空指针的解引用操作
#include <stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
return 0;
}
如果不添加对p指针的判断，当malloc函数开辟空间失败返回空指针p的时候，下面对于p+i的解引用就变成了对空指针的解引用，但是空指针只能被取地址但是不能被解引用所以出错
tips：
return 0 代表程序正常退出
return 1 代表程序异常退出
free掉部分动态开辟的内存
#include <stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*p = i + 1;
p++;
}
free(p);
p = NULL;
return 0;
}
动态开辟内存未释放（内存泄漏）
#include <stdio.h>
void test()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return;
}
//......
if (5 == 3 + 2)
{
return;
}
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
程序运行结束后free(p)的操作没有起作用，或者说test函数结束时开辟的内存空间仍未被释放，这是因为在if(5 == 3+2)的操作时函数直接返回了并未进行free操作，这种未释放开辟的内存空间的问题就叫内存泄漏
动态内存经典笔试题：
#include <stdio.h>
#include <string.h>
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test()
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str); //语法正确
}
int main()
{
Test();
return 0;
}
这个程序的问题在于，str原本是一个空指针，现在将str的值传递给了GetMemory中的指针p该过程属于传值调用（形参是实参的拷贝对形参的操作不会影响实参），然后malloc函数开辟内存空间，当GetMemory函数结束后p指针被释放但开辟的内存空间不会被释放，同时也没有一个指针指向该空间，最后str依然是一个空指针，所以无法将hello world拷贝给str指向的内存空间
该程序正确的写法如下：
#include <stdio.h>
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;
}
int main()
{
Test();
return 0;
}
有关传值调用和传址调用中的指针的值和指针的地址的补充：
指针的值：即指针变量的值，指针str的值为NULL，所以传址调用传递给p的就是NULL。
指针的地址：即对指针&后得到的值，形参是二级指针
我们将实参设置为str的地址、形参设置为char** p，此时p为二级指针它指向一级指针str所在的地址，接着我们对p解引用得到的就是一级指针str所在的地址，就可以实现对str指向空间的修改。
柔性数组
柔性数组是为了配合动态内存管理的使用，满足以下三条要求的数组我们称之为柔性数组：
1、必须位于结构体中
2、必须为最后一个成员（前面必须要有成员）
3、数组的大小必须未知
柔性数组的特点：
1、sizeof返回的结构体大小不包括柔性数组的大小
2、包含柔性数组成员的结构体⽤malloc 函数进⾏内存的动态分配，并且分配的内存应该⼤于结构体的⼤⼩，以适应柔性数组的预期⼤⼩
柔性数组的使用
#include <stdio.h>
struct st_type
{
int i;
int a[]; //柔性数组
};
int main()
{
//使用malloc开辟44个字节的空间 = 结构体成员大小 + 想要的柔性数组大小
struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用过程
int i = 0;
p->i = 100;
for (i = 0; i < 10; i++)
{
p->a[i] = i;
}
//希望结构中的a数组长度变为60个字节
struct st_type* ptr = (struct st_type*)realloc(p,sizeof(struct st_type) + 15 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
ptr = NULL;
}
else
{
perror("realloc");
return 1;
}
return 0;
}
同样的我们可以使用以下代码实现和柔性数组一样的功能：
#include <stdio.h>
struct st_type
{
int i;
int* a; //柔性数组
//在VS中int a[0]的形式也可以，但是不同编译器可能只能用其中一种
};
int main()
{
//使用malloc开辟一个大小为空间结构体大小的空间
struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type));
//对开辟失败的判断
if (p == NULL)
{
perror("malloc");
return 1;
}
//为结构体成员i赋值
p->i = 100;
//使用malloc为柔性数组开辟一个40字节大小的空间
p->a = malloc(10*sizeiof(int));
if(p->a == NULL)
{
perror("malloc");
return 1;
}
//给a指向的空间进行初始化，因为a指向的是一片空间所以可以视为数组
for (i = 0; i < 10; i++)
{
p->a[i] = i;
}
//后面我们又希望a指向的空间为15个整型
int* ptr = (int*)realloc(p->a,15 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
return 1;
}
else
{
p->a = ptr;
ptr = NULL;
}
//使用过程
free(p->a);
p->a = NULL;
free(p)
p = NULL;
return 0;
}
对于前后两者之间的对比：前者（使用一次malloc）：⽅便内存释放如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。后者（使用多次malloc）：这样有利于访问速度连续的内存空间有益于提⾼访问速度，也有益于减少内存碎⽚, 但其实没提高多少 ......
内存碎片
malloc申请内存空间时分配的内存空间是随机的，图中空白区域就是分配后剩余的内存碎片：
申请次数越多内存碎片越多
C/C++中程序内存区域划分
简单了解
栈区（stack）： 在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。 栈区主要存放运⾏函数时需要分配的局部变量、函数参数、返回数据、返回地址等堆区（heap）： ⼀般由程序员进行内存空间的分配和释放，若程序员不释放，程序结束时可能由操作系统自己回收，分配⽅式类似于链表数据段/静态区（static）： 存放全局变量、静态数据，程序结束后由系统自动释放代码段： 存放函数体（类成员函数和全局函数）的⼆进制代码
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
