每一个不曾起舞的日子,都是对生命的辜负。
动态内存管理
1. 为什么存在内存分配
我们已经掌握的开辟方式有:
int val = 20;//在栈空间开辟两个字节 char arr[10] = {0};//在栈空间开辟10个字节的连续空间
但是上述的开辟方式有两个特点:
- 1.空间开辟大小是固定的。
- 2.数组在申明的时候,必须指定数组长度,它所需要的内存在编译时分配。
- 但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道,那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态内存开辟了。
2. 动态内存函数的介绍
2.1 malloc和free
C语言提供了一个动态内存开辟的函数:
void* malloc(size_t size);
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
- 如果开辟成功,则返回一个指向开辟好空间的指针。
- 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
- 返回值的类型是void*,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
- 如果参数size为0,malloc的行为是标准还是未定义的,取决于编译器。
C语言提供了另外一个函数free,专门是用来做动态内存的释放和回收的,函数原型如下:
void free(void* ptr);
free函数用来释放动态开辟的内存。
- 如果参数ptr指向的空间不是动态开辟的,那free函数的行为是未定义的。
- 如果参数ptr是NULL指针,那么函数什么事都不做。
举个例子:
#include <stdio.h>
int main()
{
//代码1
int num = 0;
scanf("%d",&num);
int arr[num] = {0};
//代码2
int* ptr = NULL;
ptr = (int*)malloc(num*sizeof(int));
if(NULL!=ptr)//判断ptr指针是否为空
{
int i = 0;
for(i=0;i<num;i++)
{
*(ptr+i) = 0;
}
}
free(ptr);//释放ptr所指向的动态内存
ptr = NULL;//可有可无
return 0;
}
当然,代码1为变长数组,开辟空间在栈区,在c99环境下是可以的,但是由于大部分环境不为c99,因此,代码2才是我们应该选择的,其开辟的空间在堆区。
2.2 calloc
C语言还提供了一个函数叫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));//开辟10个整形的空间
if(NULL == p)
{
printf("%s\n",strerror(errno));
return 1;
}
//打印
for(int i=0;i<10;i++)
{
printf("%d ",*(p+i));
}
free(p);
p = NULL;
return 0;
}
故可以看成 calloc = malloc + memset
2.3 realloc
- realloc函数的出现让动态内存管理更加灵活。
- 有时我们会发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的申请内存,我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。
函数原型如下:
void* realloc(void* ptr,size_t size);
- ptr是要调整的内存地址
- size调整之后的新的大小
- 返回值为调整之后的内存起始位置。
- 这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间。
- realloc在调整内存空间时存在两种情况:
- 情况1:原有空间之后有足够大的空间
- 情况2:原有空间之后没有足够大的空间
- 情况1: 当是情况1的时候,要扩展内存就直接在原有内存之后直接追加空间,原来空间的数据不发生变化。
- 情况2: 当是情况2的时候,原有的空间之后没有足够多的空间时,扩展的方法是:在堆空间上另找一个合适大小的连续空间来使用,将原有的数据先拷贝到新的空间,并且继续在此后追加。这样函数返回的是一个新的内存地址。
举个例子:
#include<stdio.h>
int main()
{
int* p = (int*)malloc(40);
if(NULL == p)
{
printf("%s\n",strerror(errno));
return 1;
}
//使用
// 1 2 3 4 5 6 7 8 9 10
int i = 0;
for(i=0;i<10;i++)
{
*(p+i) = i+1;
}
//扩容
int* ptr = (int*)realloc(p,80);
if(ptr!=NULL)
{
p = ptr;
}
//使用
for(i=0;i<10;i++)
{
printf("%d ",*(p+i));//会打印1到10
}
free(p);
p = NULL;
return 0;
}
我们发现,开辟之后,新开辟的ptr的地址与p的地址相同,这就是情况1。 当然,情况2也是有可能的,我们把原有的变成4000,开辟的变成8000,,即我们申请的空间变大时:
发现变成了情况2,但此时,为什么只free掉p了呢,这是因为realloc函数会自动的把原本的空间释放掉,不需要再手动释放,因此,p原本指向的空间不用二次free。
那我们直接将realloc返回的地址赋值给原地址不行吗?
#include<stdio.h>
int main()
{
int* p = (int*)malloc(40);
if(NULL == p)
{
printf("%s\n",strerror(errno));
return 1;
}
//使用
// 1 2 3 4 5 6 7 8 9 10
int i = 0;
for(i=0;i<10;i++)
{
*(p+i) = i+1;
}
//扩容
p = (int*)realloc(p,80);
return 0;
}
我们知道,realloc存在开辟失败的可能性,若把返回值赋值给原地址,一旦开辟失败,不仅不会开辟新的空间,反而会丢失掉原来的地址,因此上述的代码存在风险,我们应该创建新的指针变量ptr,如果开辟成功,再赋值给原指针变量p。
3. 常见的动态内存错误
3.1 对NULL指针的解引用操作
void test()
{
int* p = (int*)malloc(INT_MAX/4);
*p = 20;
free(p);
}
直接*p = 20是不安全的,一旦p开辟失败,p是空指针,不能被解引用,因此,我们需要判断是否为空。
3.2 对动态开辟空间的越界访问
void test()
{
int* p = (int*)malloc(40);
if(p == NULL)
{
printf("%s\n",strerror(errno));
return 1;
}
//方式
int i = 0;
for(i=0;i<=10;i++)
{
p[i] = i;
}
free(p);
p = NULL;
}
这样的越界与非动态开辟的都是错误的。
3.3 对非动态开辟内存使用free释放
void test()
{
int a = 10;
int* p = &a;
free(p);
}
出现这种情况也是可能的,emm……,或许是喝多了。
3.4 使用free释放一块动态开辟内存的一部分
void test()
{
int* p = (int*)malloc(40);
if(p == NULL)
{
return 1;
}
//使用
int i = 0;
for(i=0;i<10;i++)
{
*p = i;
p++;
}
//释放
free(p);
p = NULL;
}
我们知道,p是int*类型,因此,其每次++都会跳过一个整形大小,因此,这样给p[i]赋值是没有问题的,但是由于其p指向的地址发生变化,当我们free§的时候,相当于free掉了从这个位置开始一直到空间结束的位置,其前面的空间并没有被free掉,这就造成了内存泄漏。
3.5 对同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(40);
if(p == NULL)
{
//……
}
free(p);
p = NULL//其二
//……
free(p);
}
或许是又喝多了,free两次一定会报错,解决的方法一是去掉一个free,其二是如上,p=NULL之后第二个free§的时候相当于free(NULL),这样的free相当于什么都没做,没有任何影响。
3.6 动态开辟内存忘记释放(内存泄漏)
void test()
{
int* p = (int*)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}
这种是最常见的错误,一旦内存泄漏过多并且不free掉,在任务管理器中会看到创建的这个项目占用了大量的系统空间,这将会造成很大的影响,因此一定要记得释放,并且正确释放。
***注:***当我们刷一系列oj题比如Leetcode,,会经常存在着不free的情况,这种情况不必担心,其上面的隐藏处理会帮助free掉。
4. 几个经典的笔试题
4.1 题目1:
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void test()
{
char* str = NULL;
GetMemory(str);
strcpy(str,"hello world");
printf(str);
}
会有什么结果?
记住:形参只是实参的一份临时拷贝,改变形参,实参并不会发生改变。因此,出现的错误:
- 1.内存泄漏,即GetMemory结束后p的地址再也找不到,free再也找不到对应的地址。
- 2.test()中的str没有被改变,仍为NULL,strcpy拷贝到空指针程序会崩溃。
那么如何修改呢?
//改法1:
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void test()
{
char* str = NULL;
GetMemory(&str);
//str存放的就是动态开辟的100字节的地址
strcpy(str,"hello world");
printf(str);
free(str);
str = NULL;
}
//改法2
char* GetMemory(char* p)
{
p = (char*)malloc(100);
}
void test()
{
char* str = NULL;
str = GetMemory();
strcpy(str,"hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
test();
}
- 通过二级指针修改
- 通过返回值修改
4.2 题目2:
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
其错误是:由于p为GetMemory内部的局部变量,当函数结束时,p自动销毁,因此str接收的为野指针。
4.3 题目3:
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
//修改如下
//free(str);
//str = NULL
printf(str);
}
这块代码出现的问题仅仅是没有free,可以打印出hello,只需要加上free即可修改。
4.4 题目4:
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
看到这里,没错,这又是一个野指针的问题,free()之后,str指向的一个空间已经被释放掉,str的地址没变,但是当strcpy拷贝world到str时,相当于找不到那个能够存放的下的空间。
5.C/C++程序的内存开辟
C/C++程序内存分配的几个区域:
- 栈区(stack):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结
束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是
分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返
回地址等。 - 堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分
配方式类似于链表。 - 数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放。
- 代码段:存放函数体(类成员函数和全局函数)的二进制代码。
有了这幅图,我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序
结束才销毁。
所以生命周期变长。
6.柔性数组
也许你从来没有听说过柔性数组(flexible array)这个概念,但是它确实是存在的。
C99 中,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员。
例如:
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
有些编译器会报错无法编译可以改成:
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;
6.1 柔性数组的特点
- 1 .结构中的柔性数组成员前面必须至少一个其他成员。
- 2.sizeof返回的这种结构大小不包括柔性数组的内存。
- 3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应大于结构的大小,以适应柔性数组的预期大小。
例如:
//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4
6.2 柔性数组的使用
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//柔性数组的使用
struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
if (ps == NULL)
{
//....
return 1;
}
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+80);
if (ptr != NULL)
{
ps = ptr;
ptr = NULL;
}
//...
//释放
free(ps);
ps = NULL;
return 0;
}
对于所谓的柔性,就是其内部的数组可以通过realloc可大可小,即在结构体内部仍然可以动态开辟内部数组。
当然,我们也可以将结构体中的整型变量与数组分开进行开辟:
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
return 1;
}
ps->n = 100;
ps->arr = (int*)malloc(40);
if (ps->arr == NULL)
{
//....
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
//扩容
int*ptr = (int*)realloc(ps->arr, 80);
if (ptr == NULL)
{
return 1;
}
//使用
//释放
free(ps->arr);
free(ps);
ps = NULL;
return 0;
}
需要注意的是要先释放内部的数组,再释放结构体,否则会找不到对应数组的地址出现内存泄漏。
6.3 柔性数组的优势
//代码1
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);
//代码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实现有两个好处:
第一个好处是: 方便内存释放。
- 如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给
用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你
不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好
了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。第二个好处是:这样有利于访问速度。
连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正
你跑不了要用做偏移量的加法来寻址)
7.总结
以上这篇文章就分享到这里啦,希望对你们有所帮助呀,看完记得动动你们发财的小手给博主支持呀!