动态内存管理 C语言从入门到入土（进阶篇）

原来45

已于 2024-06-05 17:42:01 修改

阅读量966

点赞数 34

分类专栏： C语言 C语言进阶篇文章标签： c语言开发语言后端动态内存柔性数组

于 2022-02-04 10:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_62700590/article/details/122764095

版权

C语言同时被 2 个专栏收录

76 篇文章 82 订阅

订阅专栏

C语言进阶篇

32 篇文章 16 订阅

订阅专栏

3.4 使用free释放一块动态开辟内存的一部分

首先祝大家新年快乐🎉 🎉 🎉！

hello✨，大家好呀，这里是原来💖 💛💙，随着文章篇幅越来越多可能有很多小伙伴们找不到自己想要看的文章，所以我就出来啦，这里附带各文章链接哈。🎁 🎁 🎁

C语言的入门篇和深剖篇都整理在这里了哈，进阶篇也在快赶了，用不了一周应该也就完成了，然后这里是个人主页，比点头像更好找文章哈。再是初阶的数据结构，就只剩下二叉树和八大排序了，后面会总结，链接也会放在这里哈。后面的话应该就会更c++和linux的知识了，当然，进阶的数据结构也会在c++中更新哈😜。如果你想学习c\c++方面的知识，关注博主一定会对你有所帮助哈🎁 🎁 🎁 。最后，感谢观看此篇文章的你💖，更感谢关注的你💖🎈 🎈，让我们一起加油吧！🎉 🎉 🎉

最后是打鸡血环节：改变的确很难，但结果值得冒险，拿出点勇气来。路还很长，现在才刚开始而已。过去无可挽回，未来可以改变。🚀 🚀 🚀

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进行强制类型转换)，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

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

void free (void* ptr);

free函数用来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

如果参数 ptr 是NULL指针，则函数什么事都不做。

malloc和free都声明在 stdlib.h 头文件中。

举个例子：

#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 ;

}

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 ));

        if ( NULL != p )

        {

        //使用空间

        }

        free ( p );

        p = NULL ;

        return 0 ;

}

所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

2.3 realloc

realloc 函数的出现让动态内存管理更加灵活。

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

函数原型如下：

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址

size 调整之后新大小

返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

realloc 在调整内存空间的是存在两种情况：

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

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

情况1：当是情况 1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况 2 ：当是情况 2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

由于上述的两种情况， realloc 函数的使用就要注意一些。

举个例子：

#include <stdio.h>

int main ()

{

        int * ptr = ( int* ) malloc ( 100 );

        if ( ptr != NULL )

        {

          // 业务处理

        }

        else

        {

          exit ( EXIT_FAILURE );

        }

        //扩展容量

        //代码 1

        ptr = ( int* ) realloc ( ptr , 1000 ); // 这样可以吗？ ( 如果申请失败会如何？ )



//申请失败就找不到原来的地址了，就会内存泄漏。

//所以要想代码2一样去写。

        //代码 2

        int* p = NULL ;

        p = realloc ( ptr , 1000 );

        if ( p != NULL )

        {

        ptr = p ;

        }

        //业务处理

        free ( ptr );

        return 0 ;

}

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

void test ()

{

        int * p = ( int * ) malloc ( INT_MAX / 4 );

        * p = 20 ; // 如果 p 的值是 NULL ，就会有问题

        free ( p );

}

3.2 对动态开辟空间的越界访问

void test ()

{

        int i = 0 ;

        int * p = ( int * ) malloc ( 10 * sizeof ( int ));

        if ( NULL == p )

        {

        exit ( EXIT_FAILURE );

        }

        for ( i = 0 ; i <= 10 ; i ++ )

        {

        * ( p + i ) = i ; // 当 i 是 10 的时候越界访问

        }

        free ( p );

}

3.3 对非动态开辟内存使用free释放

void test ()

{

        int a = 10 ;

        int * p = & a ;

        free ( p ); //ok?

}

也是不可以的

3.4 使用free释放一块动态开辟内存的一部分

void test ()

{

        int * p = ( int * ) malloc ( 100 );

        p ++ ;

        free ( p ); //p 不再指向动态内存的起始位置

}

3.5 对同一块动态内存多次释放

void test ()

{

        int * p = ( int * ) malloc ( 100 );

        free ( p );

        free ( p ); // 重复释放

}

3.6 动态开辟内存忘记释放（内存泄漏）

void test ()

{

        int * p = ( int * ) malloc ( 100 );

        if ( NULL != p )

        {

        * p = 20 ;

        }

}

int main ()

{

        test ();

        while ( 1 );

}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

切记：

动态开辟的空间一定要释放，并且正确释放。

4. 几个经典的笔试题

4.1 题目1：

void GetMemory ( char * p )

{

        p = ( char * ) malloc ( 100 );

}

void Test ( void )

{

        char * str = NULL ;

        GetMemory ( str );

        strcpy ( str , "hello world" );

        printf ( str );

}

请问运行Test 函数会有什么样的结果？

p是str的临时拷贝，会找不到开辟的空间。

4.2 题目2：

char * GetMemory ( void )

{

        char p [] = "hello world" ;

        return p ;

}

void Test ( void )

{

        char * str = NULL ;

        str = GetMemory ();

        printf ( str );

}

请问运行Test 函数会有什么样的结果？

这里的p也是一个局部变量。

这里值得注意的是printf可以这样使用来打印字符串。

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" );

        printf ( str );

}

请问运行Test 函数会有什么样的结果？

未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 );

        }

}

请问运行Test 函数会有什么样的结果？

说法一：提前释放

说法二：把free改为设置str为NULL，最后free。

5. C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

有了这幅图，我们就可以更好的理解在《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 柔性数组的特点：

结构中的柔性数组成员前面必须至少一个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

例如：

//code1

typedef struct st_type

{

int i ;

int a [ 0 ]; // 柔性数组成员

} type_a ;

printf ( "%d\n" , sizeof ( type_a )); // 输出的是 4

6.2 柔性数组的使用

// 代码 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 );

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

6.3 柔性数组的优势

上述的 type_a 结构也可以设计为：

// 代码 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就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.