C语言动态内存的管理

2024-04-18 18:22:13

前言

本篇博客就来探讨一下动态内存，说到内存，我们以前开辟空间大小都是固定的，不能调整这个空间大小，于是就有动态内存，可以让我们自己选择开辟多少空间，更加方便，让我们一起来看看动态内存的有关知识吧

个人主页：小张同学zkf

若有问题评论区见

感兴趣就关注一下吧

1.什么是动态内存

2. malloc和free

2.1 malloc

2.2 free

3. calloc和realloc

3.1 calloc

3.2 realloc

4. 常见的动态内存的错误

4.1 对NULL指针的解引用操作

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

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

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

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

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

5. 动态内存经典笔试题分析

5.1 题目1：

5.2 题目2：

5.3 题目3：

5.4 题目4：

6. 柔性数组

6.1 柔性数组的特点：

6.2 柔性数组的使用

6.3 柔性数组的优势

1.什么是动态内存

首先我们要搞清楚什么是动态内存的分配？

平常我们定义的数组，都是在栈区分配的空间，都是分配的空间都是固定的大小

这种分配固定大小的内存分配方法称之为静态内存分配

与静态内存相对的，就是可以控制内存的分配的动态内存分配

注意：这里动态内存分配的空间是在堆区申请的，不是在栈区申请的

我们再来看看内存各个空间都是什么

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

存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

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

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

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

2. malloc和free

我们来了解下动态内存的函数，对了以下所有函数的头文件都是<stdlib.h>

2.1 malloc

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

void * malloc ( size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

注意：

• 如果开辟成功，则返回一个指向开辟好空间的指针。

• 如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查。

• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

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

2.2 free

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

void free ( void * ptr);

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

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 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;
}

看这个例子就是典型的动态内存的开辟和回收，malloc开辟空间，然后判断一下是不是开辟空间失败，若失败返回空指针，当动态内存你使用完毕之后，用free释放，释放后的指针是野指针，记得置空。

3. calloc和realloc

3.1 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)
 {
 int i = 0;
 for(i=0; i<10; i++)
 {
 printf("%d ", *(p+i));
 }
 }
 free(p);
 p = NULL;
 return 0;
}

输出结果：

0 0 0 0 0 0 0 0 0 0

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

3.2 realloc

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

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

函数原型如下：

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

• ptr 是要调整的内存地址

• size 调整之后新大小

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

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

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

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

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

情况1

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

情况2

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
 //业务处理
 }
 else
 {
 return 1; 
 }
 //扩展容量
 
 //代码1 - 直接将realloc的返回值放到ptr中
 ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 //代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
{
 ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
}

realloc在vs上，是情况2的情况，自动释放旧的动态空间，在新的动态空间里开辟更大的空间，自动把就空间的数据拷贝一份到新空间，返回新空间的初始指针，所以不用再用free释放旧空间，只需释放realloc开批的新空间，记住realloc开辟的新空间也有可能开辟失败，若开辟失败，返回空指针。

4. 常见的动态内存的错误

4.1 对NULL指针的解引用操作

void test ()

{

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

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

free (p);

}

看这个代码，这个动态内存开辟的空间没有判断p是不是空指针，有可能内存开辟失败返回空指针，若对空指针解引用，就会非法访问出错。

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

}

仔细看这个i,当它等于10时，已经不算动态内存的开辟访问的空间范围内，是越界访问，

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

void test ()

{

int a = 10 ;

int *p = &a;

free (p); //ok?

}

这个free只能对动态内存的空间释放，注意这一点

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

void test ()

{

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

p++;

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

}

这个p指针发生改变，不在指向动态内存的起始位置，释放时只释放p现在指向的位置空间，所以只释放一部分，另一部分没释放，造成内存泄漏

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

void test ()

{

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

free (p);

free (p); // 重复释放

}

一个动态内存的开辟只能释放一次，不能多次释放

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

void test ()

{

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

if ( NULL != p)

{

*p = 20 ;

}

}

int main ()

{

test();

while ( 1 );

}

这个test函数返回时，函数空间释放，所以找不到动态内存的的地址了，但动态内存空间还没释放，并且也释放不了，就成为内存泄露的问题

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

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

5. 动态内存经典笔试题分析

5.1 题目1：

void GetMemory ( char *p)

{

p = ( char *) malloc ( 100 );

}

void Test ( void )

{

char *str = NULL ;

GetMemory(str);

strcpy (str, "hello world" );

printf (str);

}

当这个GetMemory函数返回时，函数空间释放，访问不到动态内存的空间了。但动态内存没释放，形成内存泄漏，由于形参是实参的临时拷贝，不影响str依旧是空指针，对空指针访问，程序崩溃

5.2 题目2：

char * GetMemory ( void )

{

char p[] = "hello world" ;

return p;

}

void Test ( void )

{

char *str = NULL ;

str = GetMemory();

printf (str);

}

首先注意这个GetMemory函数里是栈空间的变量数组，随着函数的释放，这个变量的空间也会释放，你虽然返回了数组首元素的地址，但是这个空间已经交还给系统，无权访问了，是野指针，所以我不确定到底能不能再次访问到这个数组，有可能还没有被系统把这个空间覆盖成其他内容，有可能访问到

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

}

这个是传str地址过去，是传址调用，那就用二级指针的形参接收，对二级指针解引用，将动态内存的首地址通过传址调用，让str接收到，所以此刻虽函数空间释放了，但我的动态内存的首地址拿到了，所以此刻这个str不是空指针了，可以strcpy，但可惜这个代码最终忘记释放str了，只有这一个小问题

5.4 题目4：

void Test ( void )

{

char *str = ( char *) malloc ( 100 );

strcpy (str, "hello" );

free (str);

if (str != NULL )

{

strcpy (str, "world" );

printf (str);

}

}

提早释放动态内存，但是只是对这个动态内存的空间没有访问的权限了，地址还是在的，通过strcpy,访问了动态内存的空间，这就是非法访问了，也就是说在没释放前，hello被拷贝过去，释放后，world无法拷贝过去

6. 柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

struct st_type

{

int i;

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

成员

};

有些编译器会报错无法编译可以改成：

struct st_type

{

int i;

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

};

6.1 柔性数组的特点：

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

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

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

typedef struct st_type

{

int i;

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

}type_a;

int main ()

{

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

return 0 ;

}

6.2 柔性数组的使用

// 代码 1

# include <stdio.h>

# include <stdlib.h>

int main ()

{

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

return 0 ;

}

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

6.3 柔性数组的优势

上述的 type_a 结构也可以设计为下面的结构，也能完成同样的效果

// 代码 2

# include <stdio.h>

# include <stdlib.h>

typedef struct st_type

{

int i;

int *p_a;

}type_a;

int main ()

{

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 ;

return 0 ;

}

上述代码 1 和代码 2 可以完成同样的功能，但是方法 1 的实现有两个好处：

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

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

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

结束语

动态内存的存储算是总结完了，动态内存我个人感觉也算是比较难，有点绕，可以多来回看看这篇博客，有什么问题跟我讨论，下一篇博客见

OK感谢观看！！！

码农公寓

1.什么是动态内存

2. malloc和free

2.1 malloc

2.2 free

3. calloc和realloc

3.1 calloc

3.2 realloc

4. 常见的动态内存的错误

4.1 对NULL指针的解引用操作

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

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

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

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

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

5. 动态内存经典笔试题分析

5.1 题目1：

5.2 题目2：

5.3 题目3：

5.4 题目4：

6. 柔性数组

6.1 柔性数组的特点：

6.2 柔性数组的使用

6.3 柔性数组的优势

相关文章