动态内存函数的介绍
- malloc
- free
- calloc
- realloc
为什么存在动态内存分配呢
int val = 20; 在栈空间上开辟四个字节
char arr[10] ={0}; 在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
1.空间开辟大小是固定的。
2.数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才能知道，
那数组的编译时开辟空间的方式就不能满足了，这时候j就只能试试动态内存开辟了
动态内存函数的介绍
malloc
malloc开辟空间 free释放空间
c语言提供了一个动态内存开辟的函数
void* malloc(size_t size);
这个函数向内存申请了一块连续可用的空间，并返回指向这块空间的指针。
1.如果开辟成功，则返回一个指向开辟好空间的指针
2.如果开辟失败，则返回一个null指针，因此malloc的返回值一定要做检查
3.返回值的类型是void*，所以malloc函数并不知道，开辟空间的类型，具体在使用的时候，使用者自己决定
4.如果参数size为0，mallocd的行为是标准是未定义的取决于编译器
free
c语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下
void free(void* ptr);
free函数用来释放动态开辟的内存
1.如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数ptr是NULL指针，则函数什么事都不做
malloc和free都声明在stdlib.h头文件中，
calloc
c语言还提供了一个函数叫calloc,calloc函数也用来d动态内存分配，
void* calloc(size_t num,size_t size);
1.函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0
2.与函数malloc的区别只在于malloc会在返回地址之前把申请的空间的每个字节初始化为全0
realloc
所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloch函数来完成任务
realloc
1.realloc函数的出现让动态内存管理更加灵活
2.有时候我们发现过去申请的空间小了，有时候我们又会觉得申请的空间过大了，那位了合理的时候内存，
我们一定会对内存的大小做灵活的调整，那realloc函数就可以做到对动态开辟内存大小的调整，函数如下
void* realloc(void* ptr,size_t size);
ptr是要调整的内存地址
size调整之后新大小
返回值为调整之后的内存起始位置
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间的是存在两种情况
情况1:原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间
malloc用法
int main()
{
//向内存申请10个整形的空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
//正常使用空间
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 = NULL;
这里的意思就是关系断了电话号码还在，
所以要把电话号码自由掉,让你忘掉这个号码
return 0;
}
calloc的用法
int main()
{
//malloc(10*sizeof(int));这里是算出总大小
int* p = (int*)calloc(10, sizeof(int));
//这里是算出几个元素，然后每个元素的大小
//calloc会把元素初始化为0 malloc不会初始化
if (p == NULL)
{
printf("%s\n", strerror(errno));//把错误码，所对应的信息打出来
}
else
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
//释放空间
//free函数是用来释放动态开辟的空间的
free(p);
p = NULL;
return 0;
}
realloc
realloc 调整动态开辟内存空间的大小
int main()
{
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
}
就是在使用malloc开辟的20个字节的空间
假设这里20个字节不能满足我们的使用
希望我们能够有40个字节的空间
这里就可以使用realloc来调整动态开辟的内存
realloc使用的注意事项：
1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域
开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间,最后
返回新开辟的内存空间地址
3.得用一个新的变量来接收realloc函数的返回值
int* ptr = realloc(p,INT_MAX);
if (ptr != NULL)
{
p = ptr;
int i = 0;
for (i = 5; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
//释放内存
free(p);
p = NULL;
return 0;
}
常见的动态内存错误
第一个错误，对NULL指针的解引用操作
int main()
{
int *p = (int*)malloc(40);
//万一malloc失败了，p就被赋值为NULL
//所以一定要进行判断
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
}
free(p);
p = NULL;
return 0;
}
第二个错误
对动态开辟内存的越界访问
int main()
{
int *p = (int*)malloc(5 * sizeof(int));//这里之开辟了5个整型元素
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
int i = 0;
for (i = 0; i < 10; i++)//这里访问了10个元素，所以越界访问
{
*(p + i) = i;
}
}
free(p);
p = NULL;
return 0;
}
第三个错误，乱用free free是堆区里面的
int main()
{
int a = 10;
int* p = &a;
*p = 20;
//对非动态开辟内存的使用free释放
free(p);
p = NULL;
return 0;
}
第四个错误
使用free释放动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 0;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*p++ = i;
}
//回收空间
free(p);//p不再指向动态内存的起始位置
这里的错误就是p释放的是后面的空间而不是开始位置的空间
p = NULL;
return 0;
}
第五个错误
对同一块动态内存多次释放
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}
第六个错误，动态开辟内存忘记释放（内存泄露）
int main()
{
while (1)
{
malloc(1);//这里没有用free进行内存释放
}
return 0;
}
忘记释放不再使用的动态开辟的空间会造成内存泄漏，切记动态开辟的空间一定要释放
并且一定要正确的释放
几道经典的笔试题
请问运行Test函数会有什么样的结果
void GetMemory(char* p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
这里程序会出现崩溃，因为访问内存失败，
因为str并没有指向有效空间，
失败原因：
1.运行代码程序会出现崩溃的现象
2.程序存在内存泄露的问题
str以值传递的形式给p
p是GetMemory函数的形参，只能函数内部有效，等GetMemory函数返回之后，动态开辟内存尚未释放，
并且无法找到，所以会造成内存泄露
printf(str);
}
int main()
{
Test();
return 0;
}
将上面的代码改进变成正确的代码
改进方法1
void GetMemory(char** p)
{
*p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
改进方法二
char* GetMemory(char* p)
{
p = (char *)malloc(100);
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
test函数执行的时候会输出什么
结构就是随机值
char* GetMemory(void)
{
char p[] = "hello world";
//这里是局部变量，只在这个函数内部有效，它的生命周期就是进入它的范围生命周期开始，出它的范围，
//生命周期结束,当出去时确实把地址返回去了，但是这个空间还给操作系统了，这个空间里面的值接下来
//是什么就是系统随机了
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}
面试模拟题 返回栈空间的问题
int* test()
{
//static int a = 10;静态区
int a = 10;//栈区
//栈区 这里给前面加上一个static就可以了
//因为static修饰局部变量，局部变量生命周期变长,a除了范围不销毁还在
return &a;
}
int main()
{
int* p = test();
*p = 20;
return 0;
}
int* test()
{
int * ptr = malloc(100);//堆区 堆空间只有free才能回收，所以这里也是可以的
return ptr;
}
int main()
{
int* p = test();
return 0;
}
面试题请问运行Test函数会有什么样的结果
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
free(str);
str = NULL;
//这里打印结果是hello
/*
忘记释放动态开辟的的内存，导致内存泄露了 要用free释放
*/
}
int main()
{
Test();
return 0;
}
void Test(void)
{
char *str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
//free释放str指向的空间后，并不会把str置为null,所以要自己加上str = null，free释放完置为空
if (str != NULL)
{
strcpy(str, "world");
//非法访问内存 你都已经把它释放了，但还是要访问它
printf(str);
}
}
int main()
{
Test();
return 0;
}
c/c++程序内存分配的几个区域
1.栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些
存储单元自动被释放，栈内存分配运算内置于处理器的指令集中，效率很高但是分配的内存容量有
限，栈区主要存放运行函数而分配的局部变量函数参数，返回数据，返回地址等
2.堆区：一般由程序员分配释放，若程序员不释放，程序结束时可能有OS回收，分配方式类似于链表
3.数据段（静态区）（static）存放全局变量，静态数据，程序结束后由系统释放
4.代码段：存放函数体（类成员函数和全局函数）的二进制d代码
实际上普通的局部变量是在栈区分配k空间的，栈区的特点是在上面创建的变量出了作用域就销毁
但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁
所以生命周期变长
柔性数组
C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做[柔性数组]成员
这两种方法都可以，如果第一种方法编译器编译不过去，那么就用第二种方法
第一种方法(1)如果编译器运行不了就用下面哪种
struct S
{
int n;
int arr[]; //结构体中最后一个元素是未知大小的
未知的大小的-柔性数组成员 -数组的大小是可以调整的
};
(2)
struct S
{
int n;
int arr[0]; //结构体中最后一个元素是未知大小的
未知的大小的-柔性数组成员 -数组的大小是可以调整的
柔性数组的具体使用
struct S
{
int n;
int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};
int main()
{ //这里就是对柔性数组进行空间创建
struct S* ps = (struct S*)malloc(sizeof(struct S) + 5*sizeof(int));
ps->n = 100; //100
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i; // 0 1 2 3 4
}
struct S* ptr = realloc(ps, 44);//进行调整对柔性数组进行调整变多点
if (ptr != NULL)
{
ps = ptr;
}
for (i = 5; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)//这里进行打印
{
printf("%d ", ps->arr[i]);
}
//释放空间
free(ps);
ps = NULL;
return 0;
}
其他的方法
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
ps->arr = malloc(5 * sizeof(int));
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 5; i++)
{
printf("%d ", ps->arr[i]);
}
//调整大小
int * ptr = realloc(ps->arr,10*(sizeof(int)));
if (ptr != NULL)
{
ps->arr = ptr;
}
for (i = 5; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
//释放内存
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}
经过两次方便比较，还是柔性数组更好一些,malloc free用的少，错误概率比较少
第二个方法错误率比较高,malloc用的越多越频繁，内存碎片越多,内存利用率低
柔性数组的特点
- 结构中的柔性数组成员前面必须至少一个其他成员
- .sizeof返回的这种结构大小不包括柔性数组的内存
- 包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小，
以适应柔性数组的预期大小
柔性数组的优点
1.方便内存释放做一次free就可以把所有的内存也给释放掉
2.这样有利于访问速度
最后介绍一位大神和它的座右铭
陈皓
