动态内存分配

已于 2023-04-11 10:10:42 修改
阅读量1k 收藏 5
点赞数 1
分类专栏： 进阶C语言 易错知识点 文章标签： c语言 Powered by 金山文档
于 2023-03-22 22:09:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74343467/article/details/129716719
版权

1.为什么存在动态内存分配

我们已经掌握的内存开辟方式有:

int va1=20;//在栈空间上开辟四个字节
char arr[10]={0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个特点:

1.空间开辟大小是固定的。

2.数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

首先，我们先了解一下：

在内存中，数据是怎么存储的呢？

2、动态内存函数的介绍

  1. malloc和free

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

void* malloc (size_t size);

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

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

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

  • 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。所以这里涉及到一个强制类型转换。

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

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

void free (void* ptr);

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

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

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

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

int main()
{
    int* p=(int*)malloc(20);
    return 0;
}

注意：返回值需要判断，因为如果太大，开辟不了，会返回空指针，开辟失败。

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n",strerror(errno));
        return 1;
    }
    //使用

    //释放
    free(p);
    p=NULL;
    return 0;
}
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
int main()
{
    int* p = (int*)malloc(20000);
    if (p == NULL)
    {
        printf("%s\n",strerror(errno));
        return 1;
    }
    //使用

    //释放
    free(p);
    p=NULL;
    return 0;
}

总的使用一下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        *(p + i) = i + 1;//p[i]=i+1;也可以
    }
    for (i = 0; i < 5; i++)
    {
        printf("%d ", *(p + i));
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

补充一下，malloc函数未初始化时是随机值。

  1. calloc函数

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

void* calloc(size_t num, size_t size);

函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。

与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节全部初始化为0。

int main()
{
    int* p = (int*)calloc(10,sizeof(int));
    int i = 0;
    if (p == NULL)
    {
        printf("calloc()--->%s\n", strerror(errno));
        return 1;
    }
    for (i= 0; i < 5; i++)
    {
        printf("%d ", *(p + i));
    }
    free(p);
    p = NULL;
    return 0;
}

由此，我们可以得出malloc和calloc之间的差别：

1.参数不一样

2.都是在堆区上申请内存空间，但是malloc不初始化，calloc会初始化为0如果要初始化，就使用calloc。

不需要初始化，就可以使用malloc。

两者各有利弊，malloc不初始化，效率更高。

  1. realloc函数

调整申请的堆区内存大小的。

现在，我们面临一个问题，刚刚申请的这块空间后面还有没有足够的空间用来完整存放数据？

如果有，realloc直接在后面开辟空间。

如果没有，realloc函数会这样做：

  1. 首先寻找更大的空间；

  1. 将原来的数据拷贝到新的空间；

  1. 释放旧的空间；

  1. 返回新空间的地址。

这种情况下，realloc函数返回的地址会变化。

如上图，就是第二种情况。

还有一种可能，realloc返回的是空指针——“调整空间失败了”。

这个时候，我们可以这样写吗？

p=realloc(p,40);

当然不行，会出问题。如果返回空指针，又赋值给p，那么p原来的数据也会丢失，造成内存泄露！

所以，正确的写法如下：

int main()
{
    int* p = (int*)malloc(200);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        *(p + i) = i + 1;//p[i]=i+1;也可以
    }
    int * ptr=realloc(p,40);
    if (ptr != NULL)
    {
        p = ptr;
        for (i = 5; i < 10; i++)
        {
            *(p + i) = i + 1;//p[i]=i+1;也可以
        }
        for (i = 0; i < 10; i++)
        {
            printf("%d ", p[i]);
        }
    }
    else
    {
        printf("realloc---> %s\n", strerror(errno));
        return 1;
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

注意，realloc函数只会把旧的数据拷贝下来，但是不会给后面新加的数据赋初值。

还有一点，当传给realloc的指针为NULL时:

当调用realloc(p,size)时，如果传来的p为NULL，那么此时 realloc就等价于malloc，而malloc返回分配的空间的首地址，因此这种特殊情况下用 p = (数据类型*)realloc(p,size)，否则将找不到新分配的空间。

这里还有一个需要注意的点：如果传给realloc函数的第一个参数是一个NULL，那么此时，realloc的功能就和malloc一样了，即：realloc也可以像malloc一样申请空间！

#include<stdio.h>
int main()
{
    realloc(NULL, 20);//malloc(20);
    return 0;
}

3、常见的动态内存错误

1、对NULL指针的解引用操作：

int main()
{
    int* p = (int*)malloc(20);
    int i = 0;
    for (i = 5; i < 10; i++)
    {
        *(p + i) = i + 1;
    }
    free(p);
    p = NULL;
    return 0;
}

没有检查指针是否为空，可能会出现对NULL指针的解引用操作。

所以对malloc函数返回的指针要进行判断。

2、对动态开辟内存的越界访问---->程序崩溃了。

int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    int i = 0;
    for (i = 0; i < 10; i++)//越界访问了
    {
        *(p + i) = i + 1;
    }
    free(p);
    p = NULL;
    return 0;
}

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

int main()
{
    int arr[10];
    int* p = arr;
    //......
    free(p);
    p = NULL;
    return 0;
}

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

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        //[1] [2] [3] [4] [5] [ ] [ ] [ ] [ ] [ ]
        *p++= i + 1;
        //*p=i+1;
        //p++;
    }
    free(p);
    p = NULL;
    return 0;
}

这个时候提供的指针p已经指向后面，无法释放。

所以最好不要用原指针进行操作。

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

int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    //......
    free(p);
    //释放
    free(p);
    p = NULL;
    return 0;
}
int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    //......
    free(p);
    p=NULL;//但是如果把它赋值成NULL，是不会有问题的。下一次p为NULL，什么都不干。
    //释放
    free(p);
    p = NULL;
    return 0;
}

但是如果把它赋值成NULL，是不会有问题的。下一次p为NULL，什么都不干。

所以把释放的指针赋值为空指针是很重要的。

这个问题经常出现在合作写代码的情况下，不知道对方释放与否。

6、忘记释放

malloc,calloc,realloc所申请的空间，如果不想使用，需要free释放。如果不自己释放，程序结束后也会由操作系统回收释放。

如果不使用free释放，程序也不结束，那么这个空间就会出现内存泄漏。

所以我们要遵循以下原则：

1、自己申请的要自己释放；

2、自己不释放的，告诉别人释放。

int main()
{
    while (1)
    {
        malloc(1);
    }
    return 0;
}

如果像上面那样一直开辟内存，但从来不回收，那么电脑的空间会被占满！

这个时候，只有使用“开机大法”了......

4、一些问题代码

1、

正确的代码应该是：

char*  GetMemory(char* p)
{
    p = (char*)malloc(100);
    return p;
}

void Test(void)
{
    char* str = NULL;
    str=GetMemory(str);
    strcpy(str,"hello world!");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}
char**  GetMemory(char** p)
{
    *p = (char*)malloc(100);
    return p;
}

void Test(void)
{
    char* str = NULL;
    GetMemory(&str);
    strcpy(str,"hello world!");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

2、

这就是返回栈空间地址的错误。要时刻注意：栈帧空间易被覆盖。

char* GetMemory(void)
{
    char* p = (int*)malloc(20);
    return p;
}

这样却是可以的，因为p指向的是malloc开辟出来的空间，这个空间出了函数是不会被销毁的。

所以下面这个代码的错误就不包括“非法访问内存”。

void GetMemory(char** p, int num)
{
    *p=(char*)malloc(num);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str，100); 
    strcpy(str,"hello"); 
    printf(str);
}
int main()
{
    Test(); 
    return 0;
}

它只是没有释放内存，这样改进就好了：

void GetMemory(char** p, int num)
{
    *p=(char*)malloc(num);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str，100); 
    strcpy(str,"hello"); 
    printf(str);
    //释放
    free(str);
    str=NULL;
}
int main()
{
    Test(); 
    return 0;
}

那这个代码呢？有没有问题？

int *f(void)
{
    int * ptr;
    *ptr=10;
    return ptr;
}

答案是：有！非法访问空间了！ptr一出函数，就会被销毁。

好，我们最后来看一个简单的代码：

改进方法是啥？显而易见：

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str,"hello");
    free(str);
    str = NULL;//自己手动将str设置为NULL。
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main() 
{
    Test(); 
    return 0;
}

5、C、C++中程序内存区域划分

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

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

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

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

4.代码段:存放函数体(类成员函数和全局函数)的二进制代码。

通过上图，我们就可以更好的理解static关键字修饰局部变量的例子了：

实际上，普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就被销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。所以它的生命周期变长。

6、柔性数组

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

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

例如：

//柔性数组

struct S
{
    int n;
    char c;
    int arr[];//柔性数组成员
    //或者，也可以写成int arr[0]-----0个大小？其实也是没有指定元素个数的，
    //语法需要罢了，这两种形式，VS上都是支持的
};

柔性数组的特点

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

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

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

//err
//struct SA
//{
//    int arr[];//柔性数组成员
//};

struct S
{
    int n;
    char c;
    int arr[];//柔性数组成员
};
int main()
{
    printf("%d\n",sizeof(strct S));//8
    return 0;
}

柔性数组的使用：

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

struct S
{
    int n;
    char c;
    int arr[0];//柔性数组成员
};

int main()
{
                     //              （   8          +             40   ）
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
    if (ps == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    //使用
    ps->n = 100;
    ps->c = 'w';
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }
    for (i = 0; i < 10; i++)
    {
        printf("%d\n", ps->arr[i]);
    }

    //调整arr数组的大小
    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
    if (ptr == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    else
    {
        ps = ptr;
    }
    //使用
    //...
    
    //释放
    free(ps);
    ps = NULL;

    //printf("%d\n", sizeof(struct S));//

    return 0;
}

但是，其实上面的代码最终为了实现的目的就是使数组“可大可小”，那我们也可以用另一种方式（指针）来实现，不一定非要用到“柔性数组”，不是吗？

struct S
{
    int n;
    char c;
    int* arr;
};

int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL)
    {
        perror("malloc");//打印错误信息码
        return 1;
    }
    int*ptr = (int*)malloc(10 * sizeof(int));
    if (ptr == NULL)
    {
        perror("malloc2：");
        return 1;
    }
    else
    {
        ps->arr = ptr;
    }
    //使用
    ps->n = 100;
    ps->c = 'w';
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }
    //打印
    for (i = 0; i < 10; i++)
    {
        printf("%d ", ps->arr[i]);
    }
    //扩容 - 调整arr的大小
    ptr = realloc(ps->arr, 20 * sizeof(int));
    if (ptr == NULL)
    {
        perror("realloc");
        return 1;
    }
    else
    {
        ps->arr = ptr;
    }
    //使用
    //...
    //释放
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

先释放arr，再释放ps。

我们来对比一下上面的两个方案：

方案1:

malloc 1次 free 1次 ， 容易维护空间，不易出错。

malloc次数少，内存碎片就会较少，内存的使用率就较高一些

方案2

malloc 2次，free 2次 ，维护难度加大，容易出错。

malloc次数多，内存碎片就会增多，内存的使用率就下降了。

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

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

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

第二个好处是:这样有利于访问速度。

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

简单地说一下：这里其实涉及到“局部性原理”，当你在访问一块内存里的数据的时候，你下一次访问的数据大概率是这块数据周围的数据，所以计算机为了提高访问速度，会提前把这些数据加载到寄存器里面去。

但是如果你的内存空间并不是连续的，那么你下一次访问的数据就不太可能出现在寄存器中，所以效率就会下降。

di-Dora
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LINUX】关于动态内存分配的理解
07-22
为什么要动态分配内存？目的是用来解决传统数组的四个缺陷。一起来看看
C 学习笔记 —— 动态分配内存（malloc）
Charles Ren's Tech Blog
02-25 2195
malloc会在内存池中找到一块空闲（连续）内存，返回内存块的首字节地址，所以可以把该地址赋值给一个指针，后面可以使用该指针访问这块内存。如果malloc分配内存失败，则他会返回一个空指针 NULL，我们可以通过是否为空指针来判断是否成功分配了内存，这个很重要。返回值类型是一个void类型的指针，该类型相当于一个通用指针，该指针通常被强转为一个匹配的类型并不需要考虑类型不匹配的问题，操作系统中可能原内存块无法改变大小，这是操作系统会分配一块新内存出来，新内存遵循上面两个规则，并将新指针返回。
数组动态分配
weixin_72051800的博客
08-14 267
1.C++通过new关键字进行动态内存分配2.C++中的动态内存分配是基于类型进行的3.通过delete关键字进行内存释放申请数组和释放的语法。
FreeRTOS内存管理
最新发布
2301_78772787的博客
06-20 770
在嵌入式系统中，内存的地址可能并不连续，这种场景下可以使用Heap_5。内存的动态管理是C程序的知识范畴，并不属于FreeRTOS的知识范畴，但是它跟 FreeRTOS关系是如此紧密，所以我们先对其进行了解。新设计中不再推荐使用Heap_2。使用内存的动态管理功能，简化了程序设计：不再需要小心翼翼地提前规划各类对象，简化API 函数的涉及，甚至可以减少内存的使用。跟 Heap_1、Heap_2 一样，Heap_4 也是使用大数组来分配内存。Heap_5 分配内存、释放内存的算法跟 Heap_4 是一样的。
malloc分配数组
被一个OIER遗弃的一堆烂代码
11-13 2881
#include <stdio.h> #include <malloc.h> int main(void) { int a[5] = {1,2,3,4,5}; int len; printf("输入分配的数组长度：len= "); scanf("%d,&len"); int * pArr = (int *)malloc(sizeof(int)*len); *pArr = 4; //类似于a[0] = 4; ...
类对象的内存和堆空间的内存及初始化详解
u011555996的博客
04-25 2759
对象的内存 对象的内存可以存在于 3 种地方： 全局区（数据段）：全局变量 栈空间：函数里面的局部变量 堆空间：动态申请内存（malloc、new等） /****************************************************** 文章目录 前言 malloc/free new/delete 申请堆空间在什么情况下会失败 malloc申请堆空间时堆空间的初始化 利用memset初始化 new申请堆空间时堆空间的初始化 前言 什么情况下需要堆空间？ 为了在程序运.
动态分配结构体数组
m0_37614810的博客
07-14 3133
在实际的编程中，数据的储存是常常遇到的，数组作为最简单实用的数据结构，常常被使用，而在c语言中数组是静态的，不允许静态的建立数组，而在实际应用中，如果固定数组的大小，在不知道输入数据的数量时，往往会造成数组定义过大，产生浪费；或是数组定义过小，不足够储存数据的问题。 除此之外，结构体能储存大量的信息且方便使用，那么可以将二者结合起来，通过动态的为结构体分配内存，来达到一个不限定大小的结构体数组用于存放数据。 实现方法如下： #include <stdio.h> #include <mall
C语言 动态内存分配详解
01-20
C语言 动态内存分配详解 动态内存分配涉及到堆栈的概念：堆栈是两种数据结构。堆栈都是数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 栈（操作系统）：由操作系统自动分配释放 ，...
c语言动态内存分配知识点及实例
12-20
在C语言中，动态内存分配是一项重要的编程技巧，它允许程序员在程序运行时根据需要分配内存，而不是在编译期间预设固定的内存空间。这种方式提高了程序的灵活性，特别是在处理不确定大小的数据集合时。 动态内存...
【CSAPP实验8】动态内存分配器
05-23
在计算机科学领域，动态内存分配是一项关键技能，尤其是在系统编程和C语言编程中。本实验“CSAPP实验8”着重探讨了动态内存分配器的设计与实现。动态内存分配允许程序在运行时请求任意大小的内存块，这与静态内存...
malloc---动态内存分配函数
weixin_48651223的博客
11-13 1078
malloc
【c语言】—动态内存分配 超详细版本
m0_74044018的博客
03-05 4654
讲解C语言中的动态内存分配，主讲malloc、calloc和realloc
C语言——动态内存分配
qq_57360359的博客
08-02 993
前面介绍静态数组不能改变长度，而动态数组可以调整数组的长度，当需要更多的空间时可以进行扩充，当数组长度过长时可以进行减小。在一个函数运行期间，系统为该函数中数组分配的空间会一直存在，直到该函数运行结束，数组的空间才会被释放。4.A函数定义的数组，在A函数运行期间可以被其他函数调用，A函数终止后不能被其他函数所调用。函数会尽可能地在原内存块上直接进行扩展或缩小，如果原内存块的大小不够，无法直接进行扩展，那么。数组的长度不能在函数运行的过程中动态的扩充或缩小。传统形式定义的数组，该数组的内存程序员无法释放。
动态内存分配：malloc、calloc、realloc（超详解析，多维度分析，小白一看就懂！！！！）
weixin_45031801的博客
11-05 5780
▶ 如果 size 为 0（开辟0个字节），malloc 的行为是标准未定义的，结果将取决于编译器。▶ 开始 指针 p 指向 int 类型 开辟的40个字节空间，并没有赋值，所以输出的值都是随机的。🔑 free()函数的头文件：#include 如果我们对于申请的内存空间的内容，要求其初始化，我们就可以使用。▶ 使用完之后一定要记得使用 free 函数释放所开辟的内存空间。🔑realloc()函数调整内存的 4 中情况：（看图解）▶ 情况二：原有空间之后没有足够大的空间。
使用malloc动态内存分配一个二维数组
eu_ler的博客
10-17 2689
由于一部分编译器（比如说vs 2019）不支持创建数组时元素个数为变量，今天使用malloc来实现此功能。 详细注释和代码如下 //动态内存分配 模拟二维数组 #include<stdio.h> #include<stdlib.h> int main() { int arr1[10]; //arr1为数组名，也是数组首元素的地址 也就是 arr1[0]的地址 //二维数组可以看 元素为int [3]类型的 元素个数为2的数组 数组首元素为第一行，arr2[0]为第一行
C语言动态内存分配详解
GG_Bruse的博客
04-18 2525
局部变量和函数的形参向栈区申请空间 全局变量和static静态变量向静态区申请空间 动态分配是既可以在堆区也可以在栈区的
c语言malloc不初始化，为什么没有占用系统空闲内存
赵凯月的博客
11-24 636
c语言malloc
【C语言】动态内存分配详解
weixin_60371270的博客
09-25 1012
这篇文章主要讲述了动态内存存在的合理性以及动态内存函数的功能，常见的动态内存有关的错误。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值