动态内存管理
2023-04-03 18:23:45 233浏览
一、为什么存在动态内存分配
我们常见的开辟空间方式有：
int a = 3;//在栈上开辟4个字节的空间
char b[10] = { 0 };//在栈上开辟10个字节的空间上面的开辟空间方式有两个特点：
①开辟的空间是固定的。
②在定义数组时，需要指定数组的大小，它所需要的内存在编译时分配。
以上的开辟空间方法在一些情况下无法满足我们的要求。比如说，我们不知道数组需要多大，需要用户输入之后才能确定大小。也就是说在程序运行时才能确定要分配的空间大小。此时用数组的定义无法实现。我们就需要用到动态内存分配的知识了。
二、动态内存函数的介绍
以下4个函数都需要引用头文件#include<stdlib.h>
1、malloc函数与free函数
以下是malloc函数的声明：
①size：是一个无符号整数，代表的是所需要开辟内存的大小，单位是字节。
②malloc函数会在堆上开辟一块size字节大小的空间，然后返回指向这块空间的指针，如果过开辟空间失败，则会返回NULL。
③如果size的大小为0，这是标准未定义的行为，实现情况根据编译器的不同而不同，可能会报错。
以下是free函数的声明：
①ptr：是一个指针，指向需要释放的内存。
②free函数能够释放动态开辟的内存。动态开辟的内存不需要时一定要用free函数释放，否则可能会出现内存泄漏等问题
③如果ptr是空指针，则什么都不会发生。
④如果ptr指向的空间不是动态开辟的，这种行为是标准未定义的，实现情况根据编译器的不同而不同，可能会报错。
下面是malloc函数与free函数的实例：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* ptr = (int*) malloc(40);//在堆上动态开辟40个字节的空间
if (ptr == NULL)//如果ptr接收的是空指针，则开辟失败
{
perror("空间开辟失败，原因是：");//提示动态内存开辟失败并打印原因
return 0;//结束
}
for (int i = 0;i < 10;i++)
{
ptr[i] = i;//用动态开辟的空间存放数据
printf("%d ", ptr[i]);
}
free(ptr);//释放空间
return 0;
}代码运行结果如下：
如果内存开辟失败：
2、calloc函数
calloc函数的声明如下：
①nums：要被分配元素的个数。
②size：元素的大小，单位是字节。
③calloc函数也是能够在堆上开辟num个大小为size的空间，与malloc函数不同的是，它会把空间的每个字节初始化为0。
④返回值是一个指向开辟空间的指针。
实例演示如下：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* pa = (int*) malloc(40);
int* pb = (int*) calloc(10, 4);//calloc函数的使用
if ((pa == NULL) || (pb == NULL))
{
perror("空间开辟失败，原因是:");
return 0;
}
//在初始化的情况下打印两块空间的数据
printf("malloc函数开辟的内存未初始化时:\n");
for (int i = 0;i < 10;i++)
{
printf("%d ",pa[i]);
}
printf("\n");
printf("calloc函数开辟的空间未初始化时:\n");
for (int i = 0;i < 10;i++)
{
printf("%d ", pb[i]);
}
free(pa);
free(pb);
return 0;
}运行结果如下：
3、realloc函数
realloc函数的声明如下：
①realloc函数能够重新调整之前用malloc函数或者calloc函数动态开辟的空间，并返回指向调整后空间的指针，如果调整失败，返回NULL。
②ptr：指向需要调整的空间的指针。
③size：调整后空间的大小，单位是字节。
③该函数在调整空间大小的同时，也会把原来空间中的数据移动到新的内存。
实例演示如下：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* ptr = (int*) calloc(10, 4);//动态开辟10*4个字节大小的空间。
if (ptr == NULL)
{
perror("calloc:Error:");
return 0;
}
//将原本40个字节的空间，调整为100个字节。
//int *ptr= realloc(ptr, 100);
//如果调整失败，realloc函数返回NULL,ptr原本指向的空间就找不到了。
int* p = (int*) realloc(ptr, 100);
//我们先设置一个中间指针，p不为空指针时才把它赋给ptr。
if (p == NULL)
{
perror("raelloc:Error:");
return 0;
}
ptr = p;//调整空间成功
p = NULL;
free(ptr);
ptr = NULL;
return 0;
}realloc函数在调整空间时可能会出现以下情况：
①原本空间之后有足够的空间，就在原本的空间后追加空间，原空间的数据不发生变化。
②原本空间之后没有足够的空间，就会在堆上另找一处开辟一块合适的空间，并把原本空间的数据转移过去。
三、动态内存的常见错误
1、对NULL指针的解引用操作
int main()
{
int* p = (int*) malloc(40);
*p = 30;//如果p的值是NULL，就会出问题
//所以，最好对malloc函数的返回值进行判断
free(p);
p=NULL;
return 0;
}2、对动态开辟空间的越界访问
int main()
{
int* p = (int*) maloc(40);
if (p == NULL)
{
perror("malloc:Error:");
return 1;
}
for (int i = 0;i <= 10;i++)
{
p[i] = i;//当i=10时越界访问了
}
free(p);
p = NULL;
return 0;
}3、对非动态开辟的空间用free函数释放
int main()
{
int a = 11;
free(&a);
return 0;
}4、对动态开辟空间的一半部分进行释放
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc:Error:");
return 1;
}
for (int i = 0;i < 5;i++)
{
*p++ = i;//在循环的过程中p指向的位置不断移动
}
free(p);//此时p指向的不是动态开辟空间的起始位置，发生错误
p = NULL;
return 0;
}5、对同一块内存的多次释放
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc:Error:");
return 1;
}
free(p);//第一次释放
//p=NULL;
//如果在第一次释放后将p置为空指针，则不会发生错误
free(p);//再次的释放，发生错误
p = NULL;
return 0;
}6、动态开辟的内存忘记释放（内存泄漏）
动态开辟的空间，如果不需要使用了，需要用free函数释放。
如果不释放，在程序结束后，也会由操作系统回收。
但是如果一个程序需要长时间运行，此时如果不使用free函数释放，操作系统无法回收，就会出现内存泄漏。通俗地说，就是这块内存你不用，也不还，别人也用不了，这块空间就相当于浪费掉了。
void test()
{
int* p = (int*)malloc(40);
if (p != NULL)
{
*p = 20;
}
//没有释放内存
}
int main()
{
test();
while (1);
//程序一直运行，出现内存泄漏
return 0;
}四、关于动态内存的题目
题目一
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;
}请问这段代码的运行结果如下：
首先进入Test函数，然后定义一个指针str，把str传给GetMemory函数。注意，此时传的是值，而不是地址。是直接把str传过去，而不是把str的地址传过去。所以p就是str的一份临时拷贝，p指向动态开辟的空间，函数结束后，p被销毁。str也不会有任何改变，依旧是一个空指针。strcpy函数调用失败，程序崩溃。所以最后什么也不会打印。
同时还有一个问题，p被销毁后，没有任何指针指向动态开辟的空间，这也就意味着我们无法主动释放动态开辟的空间，可能会出现内存泄漏。
对这段代码稍加修改：
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test()
{
char* str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}运行结果如下：
题目二
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}运行结果如下：
首先进入Test函数，定义一个字符指针str，进入GetMemory函数，定义一个字符串p，存放“hello world\0”，然后返回p的地址，由str接收。此时注意，函数结束后，函数里的数据会被销毁，空间返回操作系统。也就是说，str虽然接收到地址，但是“hello world\0”,已经被销毁了，str就是一个野指针，str指向的空间可能用来存放别的数据了，打印的结果不可预测。
题目三
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test()
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
int main()
{
Test();
return 0;
}这段代码唯一的错误就是没有把动态开辟的空间释掉。
题目四
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}str指向的空间被释放后，str没有被置为空指针，此时的str就是野指针，此时再用strcpy函数拷贝给str就会非法访问。
五、柔性数组
C99中，结构体的最后一个成员允许是未知大小的数组，这就叫做柔性数组成员。
例如：
struct S
{
int a;
int b;
char c[];//这就是柔性数组成员
};1、柔性数组的特点
①结构体柔性数组成员前面至少有一个其他成员。
②sizeof返回这种结构体的大小不包括柔性数组的内存
③包含柔性数组成员的结构体应该用malloc函数进行动态内存分配，并且分配的内存大小应该大于结构体大小，以适应柔性数组的预期大小。、
struct S
{
int a;
int b;
char c[];//这就是柔性数组
//char c[0] 这样写也行
};
int main()
{
printf("%d",(int)sizeof(struct S));//打印结果应当是8
return 0;
}2、柔性数组的使用
#include<stdio.h>
#include<stdlib.h>
struct S
{
int a;
int b;
char c[];//这就是柔性数组
};
int main()
{
// 8个字节，给a,b用 10个字节，给c用
struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));
if (p == NULL)
{
perror("malloc:Error:");
return 0;
}
p->a = 10;
p->b = 20;
for (int i = 0;i < 10;i++)
{
p->c[i] = i + 65;//使用柔性数组
}
for (int i = 0;i < 10;i++)
{
printf("%c ", p->c[i]);//打印出来看看
}
free(p);
p = NULL;
return 0;
}好博客就要一起分享哦！分享海报
此处可发布评论
评论（0）展开评论
展开评论
