[C语言]动态内存分配详解

已于 2025-02-24 09:23:12 修改
阅读量1.4k 收藏 18
点赞数 35
文章标签： c语言 开发语言
于 2025-02-24 09:22:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74978334/article/details/145819869
版权

目录

一、 为什么存在动态内存分配

二、动态内存函数的介绍

1.malloc （void* malloc (size_t size);）

①malloc 函数介绍：

②malloc函数的使用：

③注意事项：malloc函数是需要进行内存释放的，虽然在程序结束后内存会自动释放，但是如果程序一直没有结束那么需要自己先释放

2.free函数（void free (void* ptr);）

①free函数介绍：

②free函数的使用：

③注意事项：如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

3. calloc函数（void* calloc (size_t num, size_t size);//开辟num个大小为size 的空间）

①calloc函数介绍（void* realloc (void* ptr, size_t size);）：

②calloc函数的使用：

③注意事项：

（一）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。realloc在调整内存空间的是存在两种情况：

三、常见的动态内存错误

1.解引用空指针

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

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

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

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

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

四、几个经典的动态内存分配的笔试题

五、C/C++程序的内存开辟

六、柔性数组

 1.柔性数组的特点：

2 柔性数组的使用

3 柔性数组的优势

一、 为什么存在动态内存分配

int val = 20;//在栈空间上开辟固定的四个字节
char arr[10] = {0};//在栈空间上开辟固定10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

二、动态内存函数的介绍

这些函数都是在堆区存放的,使用时需要stdlib.h

1.malloc （void* malloc (size_t size);）

①malloc 函数介绍：

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

②malloc函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //申请40个字节用来存放10个整型，需强制类型转换因为malloc返回的是void*
    int* p = (int*)malloc(40);
    //需要判断是否申请成功
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
    }
    //存放1~10
    for (int i = 0; i < 10; i++)
    {
        *(p + i) = i + 1;
        printf("%d ", *(p + i));
    }
}

③注意事项：malloc函数是需要进行内存释放的，虽然在程序结束后内存会自动释放，但是如果程序一直没有结束那么需要自己先释放

2.free函数（void free (void* ptr);）

①free函数介绍：

free函数用来释放动态开辟的内存。
联想退房：把酒店的房间使用权还给酒店，房间还在那。但是和退房还是有区别，free是你把房卡没有还给酒店，你还可以通过房卡再次进入酒店，但是这个行为是非法的，而且你在房间放的东西也有可能不见了

②free函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //申请40个字节用来存放10个整型，需强制类型转换因为malloc返回的是void*
    int* p = (int*)malloc(40);
    //需要判断是否申请成功
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
                        retrurn 1；
    }
    //存放1~10
    for (int i = 0; i < 10; i++)
    {
        *(p + i) = i + 1;
        printf("%d ", *(p + i));
    }
    free(p);
    p = NULL;//在释放p地址对应的后面的空间后，p地址空间还没有释放，为了防止p被非法访问，需要将p置为空
}

③注意事项：如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

3. calloc函数（void* calloc (size_t num, size_t size);//开辟num个大小为size 的空间）

①calloc函数介绍（void* realloc (void* ptr, size_t size);）：

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
ptr 是要调整的内存地址，size 调整之后新大小，返回值为调整之后的内存起始位置。

②calloc函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{
       int* p = (int*)calloc(10, sizeof(int));
       if (NULL == p)
              {
                      perror("calloc");
                      return 1;
       }
       for (int i = 0; i < 10; i++)
       {
              *(p + i) = i;
              printf("%d " ,*(p + i));
       }
       free(p);
       p = NULL;
       return 0;
}

malloc申请到空间，没有初始化，直接返回起始地址

callloc申请好后，，会把空间初始化为0，然后返回起始地址

③注意事项：

（一）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间可以扩容，直接在后面续上新的空间返回旧的起始地址
情况2：原有空间之后没有足够大的空间，扩展的方法是：在堆空间上另找一个合适大小的连续空间，把旧的空间的数据拷贝到新空间的前面的位置，并且把旧的空间释放掉，同时返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些。

首先看下面代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{
       int* p = (int*)malloc(10, sizeof(int));
       if (NULL == p)
              {
                      perror("calloc");
                      return 1;
       }
       for (int i = 0; i < 10; i++)
       {
              *(p + i) = i;
              printf("%d " ,*(p + i));
       }
       //假如空间不够了，需要增加五个整型的空间
       int* ptr = (int*)realloc(p, 10 * sizeof(int));
       if (ptr != NULL)
       {
              p = ptr;
       }
       free(p);
       p = NULL;
       return 0;
}
所以为什么不能写成* p = ( int*)realloc(p, 10 * sizeof( int));?
realloc在扩容的时候万一失败呢？-->直接返回NULL，如果用旧的指针维护它，这样会把扩容前的数据丢失
运行结果如下：
int *p=(int *)realloc(NULL,40); 功能和malloc是一样的
也可以根据自己输入的值来开辟大小
scanf count
int *p=(int *)malloc(count*sizeof(int));
malloc、calloc、realloc、free、在内存中申请空间是通过操作系统提供的接口调用的（系统调用）

三、常见的动态内存错误

1.解引用空指针

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
       int* p = (int*)malloc(100);
       for (int i = 0; i < 20; i++)
       {
              *(p + i) = 0;
       }
       free(p);
       p = NULL;
       return 0;
}
这种操作是非常危险的，万一p指针开辟失败了为空，那么解引用就非法
malloc返回值一定要判断
修改后代码如下： 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{
       int* p = (int*)malloc(100);
       //malloc 返回值一定要判断
       if (p == NULL)
       {
              printf("%s", strerror(errno));
       }
       for (int i = 0; i < 20; i++)
       {
              *(p + i) = 0;
       }
       free(p);
       p = NULL;
       return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{
       int* p = (int*)malloc(100);
       //malloc 返回值一定要判断
       if (p == NULL)
       {
              printf("%s", strerror(errno));
              return 1;
       }
       for (int i = 0; i < 100; i++)
       {
              *(p + i) = 0;
       }
       free(p);
       p = NULL;
       return 0;
}

写的100个字节结果要访问100*sizeof(int)(400)个字节的空间

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

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{
       int a = 10;//栈区
       int* p = &a;
       free(p);
       p = NULL;
       return 0;
}

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

void test()
{
int *p = (int *)malloc(100); p++;
free(p);
}

此时的p不再指向动态内存的起始位置

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

void test()
{
int *p = (int *)malloc(100); free(p);
free(p);//重复释放
}

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

void test()
{
int *p = (int *)malloc(100); if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}

四、几个经典的动态内存分配的笔试题

下面代码运行后会有什么样的结果？

（一）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char* p)
{
    p = (char*)malloc(100);
}
void test()
{
    char* str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    test();
    return 0;
}

答：什么都不会打印

①形参只是实参的一份零时拷贝，改变p并不会改变str。
②存在内存泄漏的问题，函数在调用完后会销毁，malloc函数还来得及释放
改错： 
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char** p)
{
    *p = (char*)malloc(100);
}
void test()
{
    char* str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    test();
    return 0;
}

（二）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(void)
{
    char p[] = "hello world";
    return p;
}
void test()
{
    char* str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    test();
    return 0;
}

str为数组首元素的地址，但是在出函数后内容被销毁，再printf后就非法访问空间

这类问题被称为返回栈空间的地址问题

修改：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(void)
{
    static char p[] = "hello world";
    return p;
}
void test()
{
    char* str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    test();
    return 0;
}

（三）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char **p,int num)
{
    *p = (char*)malloc(num);
}
void test()
{
    char* str = (char *)malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main()
{
    test();
    return 0;
}

野指针非法访问，当cpy world的时候，那块空间已经释放了

修改：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char **p,int num)
{
    *p = (char*)malloc(num);
}
void test()
{
    char* str = (char *)malloc(100);
    strcpy(str, "hello");
    free(str);
    str = NULL;
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main()
{
    test();
    return 0;
}

五、C/C++程序的内存开辟

        

C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

六、柔性数组

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

例如：

typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;

 1.柔性数组的特点：

①结构中的柔性数组成员前面必须至少一个其他成员（为了好分配空间）。
②sizeof 返回的这种结构大小不包括柔性数组的内存。
③包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如： 
//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;printf("%d\n", sizeof(type_a));//输出的是4

2 柔性数组的使用

//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;printf("%d\n", sizeof(type_a));//输出的是4
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个整型元素的连续空间。

3 柔性数组的优势

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.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 (int i = 0; i < 100; i++)
    {
        p->p_a[i] = i;
    }
    //增容
    type_a *ptr=(type_a*)realloc(p, sizeof(type_a) + 20 * sizeof(char));
    if (ptr != NULL)
    {
        p = ptr;
    }
    else
    {
        return 1;
    }
    //释放空间
    free(p->p_a);
    p->p_a = NULL;
    free(p);
    p = NULL;
    return 0;
}
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正
你跑不了要用做偏移量的加法来寻址）
c语言动态内存分配
GOATLong的博客
03-25 1416
首先我们看一下该函数的声明：这个函数就是向操作系统申请一块连续可用的空间单位是字节并返回申请空间的地址。
动态内存管理
Alex的博客
04-18 257
一、为什么存在动态内存分配 我们已经掌握的内存开辟方式有： int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 但是上述的开辟空间的方式有两个特点： 空间开辟大小是固定的。 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运...
C语言 - 动态内存分配
good good study, day day up!
01-26 4795
malloc calloc relloc free 动态申请内存
C语言 | 动态内存分配
weixin_48669767的博客
04-28 346
C语言内存动态分配 在C语言中，全局变量是分配在内存中的静态存储区的，非静态的局部变量，包括形参是分配在内存中的动态存储区的，这个存储区是一个“栈”的区域。 C语言允许建立内存动态分配区域，以存放一些临时用的数据，这些数据不必在程序的声明部分定义，也不必等到函数结束时才释放，而是需要时随时开辟，不需要时随时释放。这些数据是临时存放在一个特别的自由存储区，称为“堆”。 C语言怎么建立内存的动态分配 malloc函数 函数原型 void *malloc(unsigned int size); 其作用是在内存
C语言（ 动态内存分配）
little_startoo的博客
02-14 399
动态内存分配
C语言 动态内存分配详解
01-20
C语言 动态内存分配详解 动态内存分配涉及到堆栈的概念：堆栈是两种数据结构。堆栈都是数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 栈（操作系统）：由操作系统自动分配释放 ，...
C语言动态内存分配详解（malloc/calloc/free/realloc）以及常见错误
最新发布
2302_80837091的博客
04-14 1967
当我们在计算机上打开一个程序，或者创建一个文件时，计算机需要为其分配一定的内存空间来存储程序代码和数据。内存分配是指计算机系统将可用的内存空间分配给不同的程序或文件，以让它们能够在计算机上运行或存储。内存分配是计算机操作系统中的一项重要工作，它涉及到内存的申请、分配、使用和释放等一系列操作。不同的程序或文件需要的内存空间大小不同，因此内存分配需要按需分配，以充分利用计算机的内存资源。
C语言动态内存分配详解
WZRbeliever的博客
11-22 8200
文章目录前言一、为什么存在动态内存分配1、已掌握的内存开辟方式2、上述开辟空间方式的特点3、为什么存在动态内存分配二、动态内存函数的介绍1、malloc2、free3、calloc4、realloc三、常见的动态内存错误四、几个经典的笔试题五、柔性数组总结 前言 自从前两次博客写完以后，感觉对于我本人来说，收获很大，尤其是将学过的知识再度温习一遍，感觉基础扎实了很多，所以就养成了一个习惯，每学完一个模块，都会写一篇博客，不仅仅是写个我自己的，也是想通过这篇博客，与大家分享一些我的见解。本来周四就学完了动态内
C语言 动态内存分配
Banksyw的博客
05-06 423
动态内存分配 在 C 语言中，内存分配方式不外乎有如下三种形式： 从静态存储区域分配：它是由编译器自动分配和释放的，即内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在，直到整个程序运行结束时才被释放，如全局变量与 static 变量。 在栈上分配：它同样也是由编译器自动分配和释放的，即在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元将被自动释放...
C语言动态内存分配
C++领域内容分享
10-16 1247
我们熟知的内存开辟方式有两种：第一种便是通过等关键字为变量开辟空间；第二种便是通过开辟一段连续的空间。这样开辟的空间很局限：1. 空间开辟大小是固定的。2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。动态内存分配所开辟的空间在堆区，并且是可以扩容的。
【C语言】------ 动态内存分配
Firm的博客
07-14 3452
深入了解动态内存分配！！！
【C语言】动态内存的分配
热门推荐
C、Java知识分享
01-29 1万+
动态内存的分配就那么回事儿！
C语言--动态内存分配
无知人生,记录点滴
05-12 646
1）什么是动态内存分配、静态内存分配。 百度百科中这样定义 静态内存分配：分配内存大小的是固定,比如定义一个数组，数组的大小是我们提前定义好的，一直到程序结束。 动态内存分配：动态内存分配(Dynamic Memory Allocation)就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。 2）为什么要进行动态内存分配？ （1）传统数组（即静态内存分配）有着如下缺...
C语言——动态内存分配
qq_57360359的博客
08-02 1179
前面介绍静态数组不能改变长度，而动态数组可以调整数组的长度，当需要更多的空间时可以进行扩充，当数组长度过长时可以进行减小。在一个函数运行期间，系统为该函数中数组分配的空间会一直存在，直到该函数运行结束，数组的空间才会被释放。4.A函数定义的数组，在A函数运行期间可以被其他函数调用，A函数终止后不能被其他函数所调用。函数会尽可能地在原内存块上直接进行扩展或缩小，如果原内存块的大小不够，无法直接进行扩展，那么。数组的长度不能在函数运行的过程中动态的扩充或缩小。传统形式定义的数组，该数组的内存程序员无法释放。
链表的c语言实现（一）
leton2008的专栏
04-30 2005
准备：动态内存分配一、为什么用动态内存分配但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型（存在0.5分）数组：float score[30];但是，在使用数组的时候，总有一个问题困扰着我们：数组应该有多大？在很多的情况下，你并不能确定要使用多大的数组，比如上例，你可能并不知道该班级的学生的
【C语言】动态内存分配
来杯茶_要绿的的博客
03-22 218
动态内存分配
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值