正文

C语言动态内存管理分析总结

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0630

C语言中开辟内存有很多种方式，目前我们最常用的也就是数组，但数组是在我们用到他之前就得设定好它的长度，有时很不方便。随意我们来探究动态内存管理

什么是动态内存分配

我们都知道在C语言中，定义变量的时候，系统就会为这个变量分配内存空间，而且这个空间是在栈上开辟的，这种方式就会有两个特点。

  • 开辟的空间大小是固定的
  • 数组在申明的时候，必须要指定数组的长度，以方便为其分配内存大小

但是这种方法并不能满足我们在开发中的需要，因为有时候我们需要开辟的空间大小，是在程序巡行的过程中才能知道要开辟多大的。

这时候，数组的这种开辟方式就不能满足了，因此也就有了动态内存分配的需要。

而动态内存分配，会根据需求而分配空间，大小是可以变化的，并且是在堆区上分配空间，而堆区的内存空间大小一半都会比栈区大。

动态内存函数的介绍

需要需要动态内存管理，需要了解C语言中一下的几个函数。

统一说明：一下的函数都包含在<stdlib.h>中。

free

void free (void* ptr)；

为了后面可以进行代码演示，这里先介绍free这个函数。

我们在使用相关函数动态开辟了内存空间之后，函数会返回这片空间的的首地址给使用者，当使用者用完空间之后，需要手动对这片空间进行释放，把内存空间还给操作系统。

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

上面的第一种情况，有可能编译器会报错。

如果我们仅仅只是开辟空间使用，而不释放的话，会占用内存空间资源，造成内存泄漏，影响性能。

因此，我们需要养成用完就释放的好习惯。

malloc

void* malloc (size_t size);

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

连续可用的特点，就像数组一样。

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针。
返回值的类型是 void* ，因此使用者需要根据自己的需求来转化使用。
如果参数size大小为0，malloc 的行为是标志没有规定的，取决于编译器。

size的大小是按照字节为单位的。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#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;
}

上面的代码就是malloc函数的基本使用过程，在代码1中，这样的使用方法，一般来说编译器是不支持的，而第二种方法，也就是动态内存开辟的方法，编译器就支持。

在最后，记得要把ptr所指向的空间给释放掉。

这个时候，ptr种存储的仍然是那块空间的地址，这就称为了野指针，所以我们还要把ptr置空。

calloc

与malloc类相似的，C语言还提供了另外一个动态开辟内存的函数，那就是calloc。

void* calloc (size_t num, size_t size);

需要注意的是，这个函数的参数有所不同，第一个参数num是用来确定你开辟的连续空间是用来存放多少个元素的，而第二个参数size表示的是一个元素占用多少的字节。

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

所以，如果我们需要在动态开辟内存的时候进行初始化，我们可以使用calloc这个函数。

我们可以通过调试的监视窗口来查看这个函数在开辟空间的时候是否帮我们初始化。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdlib.h>
 
 
int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    if (NULL != p)
    {
        //使用空间
    }
    free(p);
    p = NULL;
    return 0;
}

realloc

有时候我们会发现，哪怕是使用上面的动态内存管理的函数，也会有不方便的时候。我们可能会因为空间申请小了不够用而去扩容，但是如果我们使用上面两个函数去开辟更大的空间的时候，之前的数据拷贝过来新开辟的更大的空间又很麻烦。

这个时候，我们就可以使用realloc了。

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

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

在realloc函数使用的时候，会出现两种情况：

原有的空间之后还有足够的空间

如果原来的内存空间之后还有足够的空间来满足新的大小，这时候就会直接对原来的空间进行扩容，原来空间的数据不会发生变化。

原有的空间之后没有足够的空间

如果原来的空间之后没有足够的空间满足需要，就会在内存区域中开辟一片能够满足新的大小需要的连续空间，并且把原来空间的数据拷贝的新的空间中，释放原来的空间，返回新的地址。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
 
int main()
{
    int* ptr = (int*)malloc(100);
    if (ptr != NULL)
    {
        //业务处理
    }
    else
    {
        exit(EXIT_FAILURE);
    }
 
    //扩展容量
 
    //代码1
    ptr = (int*)realloc(ptr, 1000);
    
    //代码2
    int* p = NULL;
    p = realloc(ptr, 1000);
    if (p != NULL)
    {
        ptr = p;
    }
    //业务处理
    free(ptr);
    return 0;
}

上述代码种，代码1的做法是不安全的，如果我们扩容失败后，会返回空指针，这个时候，ptr接收了空指针，就会造成ptr原来的那块空间的数据丢失，并且造成内存泄漏。

因此，一般我们都需要像代码2那样，先用一个临时的指针变量接收返回值，并且在判定不为空指针后再复制给ptr。

动态内存管理中常见的错误

我们在使上面这些函数的时候，会经常出现一下的错误。

对NULL指针的解引用操作

?
1
2
3
4
5
6
7
8
void test()
{
    int* p = (int*)malloc(INT_MAX / 4);
 
    //没有进行判空，就直接使用空间
    *p = 20;//如果p的值是NULL，就会有问题
    free(p);
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
}

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

?
1
2
3
4
5
6
void test()
{
int a = 10;
int *p = &a;
free(p);
}

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

?
1
2
3
4
5
6
7
void test()
{
    int* p = (int*)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置
    //这样做一般编译器也会报错的
}

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

?
1
2
3
4
5
6
void test()
{
    int* p = (int*)malloc(100);
    free(p);
    free(p);//重复释放，一般来说，编译器会报错
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
void test()
{
    int* p = (int*)malloc(100);
    if (NULL != p)
    {
        *p = 20;
    }
}
int main()
{
    test();
    while (1);
}

我们在使用上面的函数的时候，一定要小心，避免上面的这些错误。

一些经典的笔试题

题目1

?
1
2
3
4
5
6
7
8
9
10
11
void GetMemory(char* p)
{
    p = (char*)malloc(100);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}

上面的代码有错，在开辟空间后，没有进行判空操作，并且在调用GetMemory函数的时候，传入的形参是str的一份临时拷贝，在函数内部p的改变不会改变main中的str，所以在GetMemory返回的时候，p所指向的空间会泄漏，并且在strcpy中，造成了对空指针的解引用操作。

题目2

?
1
2
3
4
5
6
7
8
9
10
11
char* GetMemory(void)
{
    char p[] = "hello world";
    return p;
}
void Test(void)
{
    char* str = NULL;
    str = GetMemory();
    printf(str);
}

这段代码也是错误的，在GetMemory中，不是用动态内存管理的函数来开辟空间，而是使用数组的开辟方式，这样的开辟方式会在栈区开辟空间，当GetMemory函数调用完成的时候，就会销毁开辟的数组，这时候，外面的str接收了返回的数组的地址，就会变成一个野指针。

题目3

?
1
2
3
4
5
6
7
8
9
10
11
void GetMemory(char** p, int num)
{
    *p = (char*)malloc(num);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}

上面的代码在使用完成动态开辟的空间后没有进行判空操作，并且没有进行内存释放，造成了内存泄漏。

题目4

?
1
2
3
4
5
6
7
8
9
10
11
void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}

上面的代码提前释放了空间，后面又使用指针对已经释放的空间进行操作，这是非法的，释放后，指向这块空间的指针就是野指针，需要进行置空。

柔性数组

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

例如：

?
1
2
3
4
5
typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;

如果有的编译器报错，可以改成下面这个样子

?
1
2
3
4
5
typedef struct st_type
{
    int i;
    int a[];//柔性数组成员
}type_a;

柔性数组的特点

结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

例如：

?
1
2
3
4
5
6
7
//code1
typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
 
//代码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个整型元素的连续空间。

柔性数组的优势

上面的代码也可以这样设计：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//代码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 的实现有两个好处：

  • 方便内存释放
  • 这样有利于访问速度

到此这篇关于C语言动态内存管理分析总结的文章就介绍到这了,更多相关C语言 动态内存管理内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/weixin_61021362/article/details/121092690