繁华声遁入空门,折煞了世人...................................................................................................
目录
前言
管理好内存才能让我们的程序效率提高,浪费更少的资源,下面让我们看一下C语言中是如何管理内存的。
一、【动态内存管理存在的原因】
在开始正式学习之前,我们首先要搞清楚,动态内存管理是什么?
简单来说就是,能够实现对内存的动态管理,包括,自由的开辟内存,扩大空间,自由的回收内存,节省空间。就比如我们上一篇博客中的通讯录的实现,那里通讯录的大小在我们最初设计时就被固定仅存放为100个联系人的信息的空间了,为了能够自由方便的管理空间,比如当空间被放满了,能够自动向内存申请空间,还有当空间充足时回收多余的空间,这些功能的实现都需要用到动态内存管理相关的知识。接下来,进入正题吧!
下面是我们已经掌握的空间开辟方法:
int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点:
1. 空间开辟大小是固定的。
2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。
但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道,
那数组的编译时开辟空间的方式就不能满足了。
这时候就只能试试动态存开辟了。
二、【动态内存开辟的函数】
2.1【malloc的介绍】
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
如果开辟成功,则返回一个指向开辟好空间的指针。
如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。注:
这里malloc的返回类型是void*,你想开辟什么类型的空间就强制类型转换为对应的类型
当你要求malloc开辟的空间过大时,malloc会开辟失败。失败会返回NULL
malloc返回的指针,在使用时,不要对其进行修改,因为该指针指向,空间起始位置,对其修改会找不到这个空间起始位置。
这里举个例子:
#include <stdio.h> #include <string.h> #include <errno.h> #include <stdlib.h> int main() { int* p = (int*)malloc(20);//向内存申请了20个字节的空间,并返回这20个字节空间的起始地址。 //判断 if (p == NULL)//malloc开辟失败会返回一个空指针,所以在使用之前,判断Malloc开辟空间是否成功。 { printf("%s\n", strerror(errno));//如果是是失败,则会在屏幕上打印失败的原因,strerror在《C语言库函数》中有详细介绍。 return 1;//开辟失败就返回1. } //使用 for (int i = 0; i < 5; i++) { p[i] = i + 1; printf("%d\n", p[i]); } //释放 free(p); p = NULL; return 0; }
2.2【free的介绍】
C语言也提供了另外一个函数free,专门是用来做动态内存的释放和回收的,函数原型如下:
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进行释放会导致的后果。在你用完了(不再使用)malloc所申请的空间之后,free可以回收空间,从而节省空间。 ptr = NULL;//置成NULL指针的目的,ptr所指向的空间已经被释放,可是ptr仍然会指向那块空间, //但是空间已经被回收无法再进行访问,如果不置空此时ptr就是野指针,后续再用到ptr就会形成非法访问 return 0; }
2.3【calloc的介绍】
C语言还提供了一个函数叫 calloc , calloc 函数也用来动态内存分配。原型如下:
1.函数的功能是为 num 个大小为 size 的元素开辟一块连续的空间,并且把空间的每个字节初始化为0。
2.与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。3.开辟失败返回NULL。
这里举例说明:
#include <stdio.h> #include <stdlib.h> int main() { int* p = (int*)calloc(10, sizeof(int)); if (NULL != p) { //使用空间 for (int i = 0; i < 10; i++) { printf("%d ", p[i]); } } free(p); p = NULL; return 0; }
所以如何我们对申请的内存空间的内容要求初始化,那么可以很方便的使用calloc函数来完成任务。
2.4【realloc的介绍】
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时候内存,我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。参数介绍
1.ptr 是要调整的内存地址
2.size 调整之后新大小
3.返回值为调整之后的内存起始位置。
4.这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况:
情况1:原有空间之后有足够大的空间解决方法:当是情况1 的时候,要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化。
情况2:原有空间之后没有足够大的空间
解决方法:当是情况2 的时候,原有空间之后没有足够多的空间时,扩展的方法是:在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。
由于上述的两种情况,realloc函数的使用就要注意一些。这里举例说明:
#include <stdio.h> #include <string.h> #include <errno.h> #include <stdlib.h> int main() { int* p = (int*)malloc(20);//向内存申请了20个字节的空间,并返回这20个字节空间的起始地址。 //判断 if (p == NULL)//malloc开辟失败会返回一个空指针,所以在使用之前,判断Malloc开辟空间是否成功。 { printf("%s\n", strerror(errno));//如果是是失败,则会在屏幕上打印失败的原因,strerror在《C语言库函数》中有详细介绍。 return 1;//开辟失败就返回1. } //使用 for (int i = 0; i < 5; i++) { p[i] = i + 1; //printf("%d\n", p[i]); } //现在讲,malloc开辟的空间进行扩容,扩充为40个字节。 int* ptr=(int*)realloc(p, 40);//由于realloc会开辟空间失败,为了防止p被赋值为NULL,使用临时指针变量ptr来暂时存放开辟空间的地址。 if (ptr != NULL)//realloc开辟失败会返回一个空指针,所以在使用之前,判断realloc开辟空间是否成功。 { p = ptr; for (int i = 5; i < 10; i++) { p[i] = i + 1; } for (int i = 0; i < 10; i++) { printf("%d\n", p[i]); } } else { printf("%s\n", strerror(errno)); return 1; } free(p); p = NULL; return 0; }
2.5【注意】
1.malloc和calloc的区别:
参数不一样
都是在堆区上申请内存空间,但是malloc不初始化,calloc会初始化为0
如果要初始化,就使用calloc
不需要初始化,就可以使用malloc
2.realloc两种情况详解:3.动态内存开辟的位置:
4.realloc也可以像malloc一样像内存申请空间。
例如:
int main() { int* pr = (int*)realloc(NULL, 20);//相当于malloc(20); return 0; }
5.C/C++程序的内存开辟
C/C++程序内存分配的几个区域:
1. 栈区(stack):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段:存放函数体(类成员函数和全局函数)的二进制代码。有了这幅图,我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁,所以生命周期变长。
7.注意点:
malloci函数和calloci函数的功能是相似的,都是申请一块连续的空间。
malloc函数中请的空间不初始化,calloci函数申请的空间会被初始化为0
realloc函数可以调整动态申请内存的大小,可大可小
三、【柔性数组】
也许你从来没有听说过柔性数组(flexible array)这个概念,但是它确实是存在的。
C99 中,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员。比如:
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 };//其中arr[]也可以写成arr[0],至于哪个正确,取决于编译器。
3.1【柔性组的特点】
1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
3.2【柔性数组的大小】
下面看一个代码:
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 }; int main() { printf("%d\n", sizeof(struct S)); return 0; }
那么我们怎么为柔性数组开辟空间呢?
事实上,当你使用柔性数组时,应该要明白自己需要多大的空间,比如我在结构体里定义了一个,int类型的柔性数组,同时我想为他开辟10个整形的空间,我就可以用malloc这样做
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 }; int main() { struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * (sizeof(int))); //printf("%d\n", sizeof(struct S)); if (p == NULL) { printf("%s\n", strerror(errno)); return 1; } //使用 p->n = 100; p->c = 'x'; for (int i = 0; i < 10; i++) { printf("%d ", p->arr[i] = i); } //释放 free(p); p = NULL; return 0; }
那么这里的柔性体现在哪呢?
首先我们使用malloc为柔性数组开辟空间,自然可以用realloc为柔性数组增加空间,柔性就体现在我们能够自由地控制柔性数组的大小。
就比如下面的代码
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 }; int main() { struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * (sizeof(int)));//申请空间 //printf("%d\n", sizeof(struct S)); if (p == NULL) { printf("%s\n", strerror(errno)); return 1; } //使用 p->n = 100; p->c = 'x'; for (int i = 0; i < 10; i++) { printf("%d ", p->arr[i] = i); } //调整 struct S* ptr = (struct S*)realloc(p, 20 * sizeof(int));//扩容 if (ptr == NULL) { printf("%s\n", strerror(errno)); return 1; } else { p = ptr; } //使用 //释放 free(p); p = NULL; return 0; }
3.3【柔性组的使用】
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 }; int main() { struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * (sizeof(int)));//其中, //printf("%d\n", sizeof(struct S)); if (p == NULL) { printf("%s\n", strerror(errno)); return 1; } //使用 p->n = 100; p->c = 'x'; for (int i = 0; i < 10; i++) { printf("%d ", p->arr[i] = i); } //释放 free(p); p = NULL; return 0; }
3.4【柔性数组的优点】
代码1.
struct S { int n; char c; int arr[];//结构体最后一个成员,且没有指定大小。就叫做柔性数组成员。 }; int main() { struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * (sizeof(int)));//其中, //printf("%d\n", sizeof(struct S)); if (p == NULL) { printf("%s\n", strerror(errno)); return 1; } //使用 p->n = 100; p->c = 'x'; for (int i = 0; i < 10; i++) { printf("%d ", p->arr[i] = i); } //调整 struct S* ptr = (struct S*)realloc(p, 20 * sizeof(int)); if (ptr == NULL) { printf("%s\n", strerror(errno)); return 1; } else { p = ptr; } //使用 //释放 free(p); p = NULL; return 0; }
代码2.
struct S { int n; char c; int* arr; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S)); if (ps == NULL) { perror("malloc"); return 1; } int* pa = (int*)malloc(10 * sizeof(int)); if (pa == NULL) { perror("malloc"); return 1; } else { ps->arr = pa; } ps->n = 100; ps->c = 'x'; for (int i = 0; i < 10; i++) { printf("%d ", ps->arr[i] = i); } //调整 pa = realloc(ps->arr, 20 * sizeof(int)); if(pa == NULL) { perror("realloc"); return 1; } else { ps->arr = pa; } //使用 //释放 free(ps->arr); ps->arr = NULL; free(ps); ps = NULL; return 0; }
上述 代码1 和 代码2 可以完成同样的功能,但是 方法1 的实现有两个好处:
第一个好处是:方便内存释放
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
第二个好处是:这样有利于访问速度.连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)
四、【题目练习】
4.1【易错分析】
1.对NULL指针的解引用操作
int main() { int* p = (int*)malloc(20);//这里应该对p进行判断,因为malloc开辟失败,就会返回NULL for (int i = 0; i < 5; i++) { p[i] = i; } free(p); p = NULL; return 0; }
2.对动态开辟空间的越界访问
#include <errno.h> int main() { int* p = (int*)malloc(20); if (p = NULL) { printf("%s\n", strerror(errno)); return 1; } for (int i = 0; i < 10; i++)//这里出现了越界访问,因为malloc开辟的空间为20个字节,是5整形, //这里循环到10,多余大于malloc开辟的空间。 { p[i] = i; } free(p); p = NULL; return 0; }
3.对非动态开辟内存使用free释放
int main() { int arr[10] = { 1,2,3,4,5 }; int* p = arr; //进行对p的使用 free(p);//这里p不是动态内存,所以不能用free释放。 p = NULL; return 0; }
4.使用free释放一块动态开辟内存的一部分
int main() { int* p = malloc(100); if (p = NULL) { printf("%s\n", strerror(errno)); return 1; } p++;//这里开始时,p指向malloc开辟空间的起始位置,,对p进行++操作,改变了p的指向, //所以free的时候,并没有完全把malloc来的空间释放掉。 free(p); p = NULL; return 0; }
5.对同一块动态内存多次释放
int main() { int* p = (int*)malloc(100); if (p = NULL) { printf("%s\n", strerror(errno)); return 1; } //使用 free(p);//这里提前被释放了一次,就不能再释放了但是可以写成 //free(p); // p=NULL; //释放 free(p); p = NULL; return 0; }
6.动态开辟内存忘记释放(内存泄漏)
void test() { int* p = (int*)malloc(100);//出了函数p被销毁,函数没有把p返回,自然也无法释放,那么这100个字节的内存就泄露了。 if (NULL != p) { *p = 20; } } int main() { test(); while (1); }
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
总结:
动态开辟的空间一定要释放,并且正确释放 。
malloc
calloc
realloc
1.所申请的空间,如果不想使用,需要free释放。
2.如果不使用free释放:程序结束之后,也会由操作系统回收,如果不使用free释放,程序也不结束就会导致内存泄露。
3.所以我们在使用这些函数时,尽量做到自己申请的,尽量自己释放,自己忘了释放的,告诉使用者进行释放。
4.2【专项题目】
题目1.
void GetMemory(char* p) { p = (char*)malloc(100); } void Test(void) { char* str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); //这里需要讲解,我们常见的打印字符串的方式为: //printf("%s\n",str); //或者printf("hello world\n");//这里本质上,根据hello world的首字符地址进行打印的 //所以这里的printf(str);,也是根据首字符地址进行打印。 } int main() { Test(); return 0; }
1.调用GetMemoryl函数的时候,str的传参为值传递,p是str的临时
拷贝,所以在GetMemory函数内部动态开辟空间的地址存放在p中的时候,不会影响str.所以GetMemory函数返回之后,str中依然是NULL指针。strcpy函数就会调用失败,原因是对NULL的解引用操作,程序会崩溃。
2.GetMemory函数内容malloc申请的空间没有机会释放,造成了内存泄露。题目2.
char* GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char* str = NULL; str = GetMemory(); printf(str); } int main() { Test(); return 0; }
这里形成非法访问
题目3.
void GetMemory(char** p, int num) { *p = (char*)malloc(num); //没有对p进行释放和置空。 } void Test(void) { char* str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); } int main() { Test(); return 0; }
题目4.
void Test(void) { char* str = (char*)malloc(100); strcpy(str, "hello"); free(str); //这里没有置空,str=NULL; if (str != NULL) { strcpy(str, "world");//这里会形成非法访问。 printf(str); } } int main() { return 0; }
总结
提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pandas的使用,而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
.............................................................................缘份落地生根是我们,伽蓝寺听雨声盼永恒
————《烟花易冷》