C/C++内存管理以及动态内存的申请

最新推荐文章于 2024-07-25 20:01:09 发布

Demo Test

最新推荐文章于 2024-07-25 20:01:09 发布

阅读量1.6k

点赞数 1

分类专栏： C语言文章标签： c++ c语言

本文链接：https://blog.csdn.net/z123zqzzxvvb/article/details/129285098

版权

C语言专栏收录该内容

11 篇文章 1 订阅

订阅专栏

1.虚拟内存布局

栈
堆
数据段
代码段

一个用户进程可以访问的内存区域介于 0x0804 8000 和 0xc0000000 之间，这个“广袤”的区域又被分成了几个部分，分别用来存放进程的代码和数据。

1.1 栈内存（stack）

存放了什么东西
- 环境变量
- 命令行参数
- 局部变量（包括形参）
栈空间有什么特点
- 空间是有限（ulimit 可尝试查看）默认情况下栈的大小为 8M ，在嵌入式开发的时候应该尽可能的减少使用栈空间
- 栈空间的增长，从上（高地址）往下（低地址）
- 每当有一个函数被调用的时候，栈就会从上往下分配一个段，这一段空间就是一个栈帧，该内存空间用来存放该函数的局部变量。
- 当有一个函数退出的时候，栈空间会从下往上释放一个栈帧，将所有的内存归还给系统。
注意：
- 栈空间中的内存存放的数据值是未知的，因此每一个局部变量在使用之前最好做好初始化
- 栈内存的空间我们无法手动实现申请与释放，都是由系统自动完成，我们无法干预。

栈的增长方式，从高地址到低地址。
栈顶：栈的顶部（相对来说地址值比较小的）可以楼顶来理解
栈底：栈的底部（栈的起始地址0xC000 0000 ）相当于楼底

1.2数据段（静态区）：

数据段中存放什么：
- 静态数据（已初始化、未初始化）
  - 被static修饰的局部变量
- 全局变量
- 常量

数据段的特点：

它的生命周期与进程保持一致
什么是程序什么是进程？
程序 : 是指编译后的可执行文件，它存放于硬盘。他相当于一个剧本。
进程：是指把程序文件加载到内存中并逐步执行该文件中的二进制指令。进程所占用的空间是内存空间。

1.3代码段

.text段：
- 存放用户的二进制代码（mian func …）函数体（类成员函数和全局函数）
.init 段：
- 当程序运行之初的一些初始化的工作（由编译器根据系统来对应添加的）

1.4堆区（heap）

一般由程序员分配释放，若程序员不释放，程序结束时可能由系统(OS)回收。分配方式类似于链表。
堆空间特点：

相对于栈空间来说，堆的内存空间相对大很多（堆内存的大小取决于实际的物理内存大小）
堆空间的增长方式，从下（低地址）往上（高地址）
堆空间中的内存都属于匿名空间，因此需要借助指针来访问
有开发者自行申请和释放的，如果没有释放那么这个空间用于存在。直到程序结束。

相关的API 接口：
申请：malloc / calloc / realloc
释放： free

2.动态内存函数的介绍

2.1 malloc和free

C语言提供了一个动态内存开辟的函数：

malloc ( 申请堆内存空间 )
头文件：
    #include <stdlib.h>
定义函数：
    void *malloc(size_t size);
参数分析：
    size --> 需申请的堆空间的大小（字节为单位）
返回值：
    成功：返回一个指针，该指针指向申请的入口地址
    失败：返回NULL

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的。
函数原型如下：

free ( 释放原先配置的内存 )
头文件：
    #include <stdlib.h>
定义函数：
    void free(void *ptr);
参数分析：
	ptr --> 需要释放的堆空间的入口地址
返回值：
    无

free函数用来释放动态开辟的内存。如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

例子：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

int main()
{
    // int* p = malloc(10*sizeof(int));     //10个int型那就是四十个字节
    int* p = (int *)malloc(10*sizeof(int)); 
    if (p == NULL)
    {
        printf("%s\n" ,strerror(errno));    //打印一个错误原因的一种方式
        // perror("calloc error");
    }
    else
    {
        int i = 0;
        for (i = 0; i < 10; i++)    //往空间里面赋值
        {
            *(p+i) = i;
        }
        
        for (i = 0; i < 10; i++)    //打印输出
        {
            printf("%d" ,*(p+i) = i);
        }
    }

    free(p);    //释放内存空间
    p = NULL;	//让指针指向空
    return 0;
}

2.2calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。
原型如下：

calloc  ( 配置内存空间并把该内存清空为 0 )
头文件:
    #include <stdlib.h>
定义函数:
    void *calloc(size_t nmemb, size_t size);
参数分析：
    nmemb --> 需要申请的内存块的个数
    size  --> 每一块内存的大小
返回值：
	成功 返回一个指针指向给内存
    失败 返回NULL

函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。
例子：

int main()
{
    // int* p = malloc(10*sizeof(int)); //申请空间后，不会自动初始化
    int* p = calloc(10 ,sizeof(int));   //申请空间后，会自动初始化为0
    if (p == NULL)
    {
        printf("%s\n" ,strerror(errno));    //打印一个错误原因的一种方式
        // perror("calloc error");
    }
    else
    {
        for (int i = 0; i < 10; i++)
        {
            printf("%d",*(p+i));
        }        
    }

    free(p);
    p == NULL;
    return 0;
}

2.3 realloc

realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下：

realloc （重新分配内存空间）
头文件：
 	#include <stdlib.h>
函数原型：
    void *realloc(void *ptr, size_t size);
参数分析：
    ptr --> 原本的内存的入口地址 ，  如果为NULL 则表示新申请与malloc 一致
    size --> 目标大小（更改后的大小） ， 如果设置为 0 相当于 free(ptr) 释放了内存
返回值：
    成功 返回新的入口地址
    失败 返回空NULL

ptr 是要调整的内存地址
size调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

realloc在调整内存空间的时候存在以下两种情况：

情况1：原有空间之后有足够大的空间

这种时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况2：原有空间之后没有足够大的空间

则realloc函数会重新找一个新的内存区域开辟一块满足需求的空间，并且把原来内存中的数据拷贝出来，放到新的内存空间，然后释放旧的内存空间！最后返回新开辟的内存空间地址！！
总结：realloc函数在使用时得用一个新的变量来接受realloc函数的返回值！！！

例子：

int main()
{
    int* p = 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) = i);
        }
    }

    /*realloc函数除了可以调整原有的旧空间，还可以开辟新空间，其功能跟malloc函数一样*/
    // int* ptr = realloc(NULL ,10*sizeof(int));   //第一个参数传NULL指针就好了。

    /*realloc使用的注意事项：
        1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p的地址。
        2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域
        开辟一块满足需求的空间，并且把原来内存中的数据拷贝出来，放到新的内存空间，然后释放旧的内存空间！
        最后返回新开辟的内存空间地址！！
        3.得用一个新的变量来接受realloc函数的返回值*/
    
    int* ptr = realloc(p ,20*sizeof(int));	//调整原有内存
    if (ptr != NULL)
    {
        p = ptr;     //这里注意接收函数的返回值！如果开辟成功，把新地址赋值给P
        for (int i = 10; i < 20; i++)    //往空间里面赋值
        {
            *(p+i) = i;
        }

        for (int j = 10; j < 20; j++)
        {
            printf("%d " ,*(p+j));
        }
    }

    free(p);
    p = NULL;
    return 0;
}

总结：

malloc 函数申请堆空间与 calloc的区别，前者没有清空内存，后者默认把内存清空为 0
realloc 用于重新申请堆空间，有可能那个会重新开辟新的空间，并保持原有的数据不变
- 如果ptr 参数为 NULL 则表示新申请与malloc 一致
- 如果size 设置为 0 相当于 free(ptr) 释放了内存
free 释放堆空间
- 只是把内存空间归还给系统，没有把内存进行清空
- 也没有把指针指向NULL ，因此最好手动让指针指向 NULL避免野指针的出现
- 不允许释放其他区域的内存

3.动态开辟内存的常见错误

对NULL指针的解引用操作
对动态开辟空间的越界访问
对非动态开辟内存使用free释放
使用free只释放一块动态开辟内存的一部分

int main()
{
    int* ptr = malloc(10*sizeof(int));
    if (ptr == NULL)
    {
        printf("%s\n" ,strerror(errno));
    }
    for (int i = 0; i < 10; i++)
    {
        *ptr++ = i;     
    }
    /*错误的！！！这里我们已经让ptr变化了，ptr指向的已经不是刚刚动态开辟出来的
    	那块空间的起始位置了。只能从起始位置开始释放！！！
    	不能只释放其中的一部分*。解决方法是：用起始地址加下标的方式访问*/
    free(ptr);
    ptr = NULL;
    
    return 0;
}