动态内存开辟必看，一篇就能学会贯通

最新推荐文章于 2024-03-21 23:54:41 发布
置顶 最新推荐文章于 2024-03-21 23:54:41 发布
阅读量1.4k 收藏 16
点赞数 35
分类专栏： 动态内存开辟 文章标签： c语言 算法 开发语言 c++ c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Williamtym/article/details/128784767
版权

目录

为什么存在动态内存分配

动态内存函数的介绍

1.malloc函数和free函数

2.calloc函数

3.realloc函数

常见的动态内存错误

经典的笔试题

柔性数组

                                         今天来介绍一下动态内存，让我们直入主题！！！！！

 

为什么存在动态内存分配

目前我们掌握的内存开辟的方式有：

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

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

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

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

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

动态内存开辟
栈区局部变量、函数形参
堆区动态内存开辟
静态区（数据段）全局变量、静态变量

动态内存开辟：malloc()    free()   realloc()    calloc()

动态内存函数的介绍

 

1.malloc函数和free函数

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

 

malloc

void* malloc(size_t size)

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

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

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

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

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

free

void free(void* ptr);

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

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

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

        malloc和free都声明在stdlib.h头文件中,一般都是成对出现。

#include<stdio.h>
#include<stdlib.h>
//动态内存开辟
int main()
{
    //假设开辟10个整型的空间 - 10* sizeof(int)
    int arr[10];//栈区
    //动态内存开辟
    int* p = (int*)malloc(10*sizeof(int));//void*,最好强制类型转换
    if(p == NULL)
    {
        perror("main");//main:xxxxxxxxx
        return 0;
    }
    //使用
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        *(p + i) = i;
    }
    for(i = 0;i < 10; i++)
    {
        printf("%d ",p[i]);//p[i] 等价于 *(p+i)
    }
    //回收空间
    free(p);
    p = NULL;//自己动手才能把p赋值为空指针
    return 0;
}

2.calloc函数

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

void* calloc(size_t num, size_t size);

        calloc函数会初始化内存，而malloc函数不会。

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

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int*p = (int*)malloc(40);
    if(p == NULL)
        return 1;
    for(int i = 0;i < 10; i++)
    {
        printf("%d\n",*(p + i));
    }
    free(p);
    p = NULL;
    return 0;
}
7561600
0
7536976
0
1986622020
1631875685
1157652852
1413694796
1598967634
1598969170

        我们发现malloc函数确实不能初始化内存，如果用calloc函数就可解决这个个问题。

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

3.realloc函数

 

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

  2. 有时候我们发现过去申请的空间太小了，有时候我们又觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小作灵活调整。那realloc函数

  3. 当我们需要扩大空间的时候，会有后面空间不够的情况，为了避免占用已经分配好的空间位置，realloc函数会在堆区空间充足处重新拷贝上面的内容，并把重新分配到的地址传回指针，把原来的空间还给操作系统。

  4. realloc函数可能找不到合适的空间来调整空间，就会返回NULL。

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

  1. ptr是要调整的内存空间

  2. size调整之后的新的大小

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

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    if(p == NULL)
    {
        perror("main");
        return 1;
    }
    //使用
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        *(p + i) = 5;
    }
    //这里需要p指向的空间更大，需要20个int的空间
    //realloc调整空间
    int* ptr = (int*)realloc(p, 20*sizeof(int));//因为realloc函数可能传回空指针，为了原先空间不丢失，故临时创建指针接受
    if(ptr != NULL)
    {
        p = ptr;
    }
    free(p);
    p = NULL;
    return 0;
}

情况1

        情况一是后面有充足的空间。要扩展内存就直接在原有内存之后追加空间，原有空间不发生变化。

情况2

        情况二是后面空间不足。在这种情况下，原有空间不足的拓展办法是在对空间另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址，原有空间还给操作系统。

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int*p = (int*)realloc(NULL, 40);//这里的功能类似于malloc，就是在堆区开辟40个字节
    return 0;
}

常见的动态内存错误

 

对NULL指针的解引用操作

void test()
{
    int* p = (int*)malloc(INT_MAX/4);
    *p = 20;//如果p的值是NULL，就会有问题
    free(p);
}
void test()
{
    int* p = (int*)malloc(10000000000000);
    //要对malloc函数的返回值，做判断
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        *(p + i) = i;
    }
    free(p);
}

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

#include<stdio,h>
#include<stdlib.h>
int main()
{
    int* p = malloc(10 * sizeof(int));
    if(p == NULL)
    {
        return 1;
    }
    int i = 0;
    //越界访问
    for(i = 0;i < 40; i++)
    {
        *(p + i) = i;
    }
}

对非动态内存函数使用free

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int arr[10] = { 0 };
    int* p =arr;
    //使用非动态内存空间是错误的
    free(p);
    p = NULL;
    return 0;
}

使用free函数释放动态内存中一部分

int main()
{
    int* p = malloc(10 * sizeof(int));
    if(p == NULL)
    {
        return 1;
    }
    for(int i = 0;i < 5; i++)
    {
        *p++ = i;//指针p往后走，起始位置改变
    }
    free(p);
    return 0;
}

对同一块动态开辟内存进行多次释放

int main()
{
    int* p = (int*)malloc(100);
    //使用
    //释放
    free(p);
    //释放
    free(p);//两次明目张胆地释放同一块空间是绝对不可以的
    return 0;
}

        当然也可以规避这个问题，那就是把p指针赋值为NULL，那么再次free是没有问题的，看如下代码：

int main()
{
    int* p = (int*)malloc(100);
    //使用
    //释放
    free(p);
    p = NULL;
    //释放
    free(p);
    return 0;
}

动态开辟的空间忘记释放

void test()
{
    int* p = (int*)malloc(100);//内存泄漏
    if(p == NULL)
    {
        return;
    }
    //使用
}
int main()
{
    test();
    //……
    return 0;
}

动态开辟空间回收方式：

  1. 主动释放，free

  2. 程序彻底结束

经典的笔试题

 

第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地址，所以p也存放了NULL空指针。然后申请了100字节，地址传给p，但是p是形参局部变量，p返回之后就会销毁。所以str没有指向任何一个空间，所以没有办法获得空间拷贝hello world

        str传给GetMemory函数的时候是值传递，所以GetMemory函数的形参p是str的一份临时拷贝。在GetMemory函数内部动态申请空间的地址，存放在p中，不会影响外边的str，所以当GetMemory函数返回之后，str仍然是NULL，所以strcpy会失败。

        当GetMemory函数返回之后，形参p销毁，使得动态开辟的100个字节存在内存泄漏。无法释放。

修改如下：

修改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;
}

修改2：

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

第2题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//GetMemory函数内部创建的数组是在栈区上创建的
//出了函数，p数组的空间就还给了操作系统
//返回的地址是没有实际的意义，如果通过返回的地址去访问内存就是非法访问地址
char* GetMemory(void)
{
    char p[] = "hello world";
    return p;
}//出了这个括号就销毁了，叫做返回栈空间地址的问题
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    Test();
    return 0;
}

无法得到想要的结果

数组p里放了：hello world\0

str : NULL

char* GetMemory(void) { char p[] = "hello world"; return p; }//出了这个括号就销毁了

这种问题叫做返回栈空间地址的问题

第3题

void Test(void)
{
    char *str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);
    if(str != NULL)//非法访问
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main()
{
    Test();
    return 0;
}

free以后的str一定要指空，如果不把str=NULL的话，就是非法访问

第4题

test.c文件中包括如下语句：
#define INT_PTR int*//INT_PTR是一个指针
typedef int* int_ptr;//typedef是类型重定义
INT_PTR a,b;//int* a,b;
int_ptr c,d;//int* c,*d;
文件中定义的四个变量，哪个变量不是指针类型：（b）

百度程序题

int *f1(void)
{
    int x = 10;//x是局部变量，处于栈区，返回地址无用
    return(&x);
}
​
int *f2(void)
{
    int *ptr;
    *ptr = 10;//ptr是一个野指针
    return ptr;
}
​
​

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

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

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

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

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

柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做[柔性数组]成员。

例如：

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员，大小是未知的
}type_a;

柔性数组的特点：

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

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

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

#include<stdio.h>
struct S
{
    int n;
    int arr[0];//大小未知
};
​
int main()
{
    struct S s = {0};
    printf("%d\n",sizeof(s));
    return 0;
}
输出结果：4//sizeof返回不包括柔性数组大小

利用malloc函数开辟空间

写法1

#include<stdio.h>
#include<stdlib.h>
struct S
{
    int n;
    int arr[0];//大小未知
};
​
int main()
{
    //期望arr的大小是10个整型
    struct S*ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
    ps->n = 10;
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        ps->arr[i] = i;
    }
    for(i = 0;i < 10; i++)
    {
        printf("%d ",ps->arr[i]);
    }
    //增加
    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+20*sizeof(int));
    if(ptr != NULL)
    {
        ps = ptr;
    }
    //释放
    free(ps);
    ps = NULL;
    return 0;
}

还可以利用指针来替代柔性数组写成如下代码

写法2

#include<stdio.h>
#include<stdlib.h>
struct S
{
    itn n;
    int* arr;
};
​
int main()
{
    struct S* ps = (struct S*)malloc(szieof(struct S));
    if(ps == NULL)
    {
        return 1;
    }
    ps->arr = (int*)malloc(10* szieof(int));
    if(ps->arr == NULL)
    {
        return 1;
    }
    for(int i = 0;i < 10;i++)
    {
        ps->arr[i] = i;
    }
    //增加
    int* ptr = realloc(ps->arr, 20*sizeof(int));
    if(ptr != NULL)
    {
        ps->arr = ptr;
    }
    //先free第二块空间，如果free第一块的话就会造成地址丢失，就会造成内存泄漏
    //两次malloc需要两次free
    //释放
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

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

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

  2. 第二个好处是：这样有利于访问速度 连续的内存有益于提高访问速度，也有益于减少内存碎片(其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）。

酷壳——CoolShell的《C语言结构体里的成员数组和指针》

内存池的概念

  内存池是一种内存分配方式。通常我们习惯直接使用new、malloc等接口申请内存，这样做的缺点在于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。

  内存池则是在真正使用内存之前，预先申请分配一定数量、大小相等（一般情况下）的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。

内存池的流程和设计

  1. 先申请一块连续的内存空间，该段内存空间能够容纳一定数量的对象。

  2. 每个对象连同一个指向下一个对象的指针一起构成一个内存节点（Memory Node）。各个空闲的内存节点通过指针形成一个链表，链表的每一个内存节点都是一块可供分配的内存空间。

  3. 某个内存节点一旦分配出去，从空闲内存节点链表中去除。

  4. 一旦释放了某个内存节点的空间，又将该节点重新加入空闲内存节点链表。

  5. 如果一个内存块的所有内存节点分配完毕，若程序继续申请新的对象空间，则会再次申请一个内存块来容纳新的对象。新申请的内存块会加入内存块链表中。

局部性原理

  1. 空间局部性：当使用一个空间的情况下，80%的可能会使用周边的空间，不会随意随机地挑选空间。效率会高一些。

  2. 一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也将被访问，即程序在一段时间内所访问的地址，可能集中在一定的范围之内，这是因为指令通常是顺序存放、顺序执行的，数据也一般是以向量、数组、表等形式簇聚存储的。——如果一个存储器的位置被引用，那么将来他附近的位置也会被引用。

  3. 时间局部性：

    如果程序中的某条指令一旦执行，不久以后该指令可能再次执行;如果某数据被访问过，不久以后该数据可能再次被访问。产生时间局部性的典型原因，是由于在程序中存在着大量的循环操作。——被引用过一次的存储器位置在未来会被多次引用（通常在循环中）。

        当然有些编译器会报错无法编译

         希望大家能点个赞支持一下！！！！蟹蟹蟹蟹！！！

 

Williamtym
关注
  • 35
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
C语言中动态内存的开辟
输出分享
04-18 1763
简洁细致的概括和使用动态内存的相关库函数，把内存的使用变得灵活！
动态内存开辟
2303_77982246的博客
08-15 63
1.为什么存在动态内存分配：对于一部分数组，我们一开始可能不知道该设置多大，为了满足条件，尽可能设置大一点，但实际可能只用了一小部分，造成了内存浪费，这时就需要我们动态的管理内存，需要时再增加内存2.动态内存函数的介绍开辟size个字节的空间，开辟成功则返回该空间的地址，开辟失败则返回空指针int main()return 1;return 0;释放动态开辟的内存，避免内存泄漏。p = NULL;
[C语言]动态内存的开辟
weixin_43908419的博客
11-30 1317
本文介绍了C语言动态内存开辟相关的知识。涉及到动态内存开辟的常用函数（malloc、free、calloc及realloc），还介绍了动态内存开辟常见的错误，最后介绍了柔性数组相关的知识。
鹏哥C语言复习——动态内存开辟
最新发布
2302_80297338的博客
03-21 942
动态内存函数共有4概念介绍：结构体中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员柔性数组的初始化方式：a[ ] 或者 a[0]（具体用哪个看编译器）1.结构体中的柔性数组成员前必须至少一个其他成员2.sizeof返回的这种结构体大小不包括柔性数组的内存3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小4.一个结构体里，柔性数组只能出现一个struct Sint n;int arr[];
C语言之动态内存开辟
weixin_57104108的博客
08-28 1231
在了解动态内存前，我们先简单介绍一下关于Win系统的内存分配问题，有助于对内存空间的进一步理解：在Win（X86）系统中，共分配4G内存空间，而这4G内存空间共分为4个区，分别为：代码区，数据区，堆区，栈区。将大致的示意图表示如下：代码区：存放 CPU 执行的机器指令（函数体的二进制代码），即将编译器中的代码进行汇编后得到的代码。代码区具有共享性与只读性；即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。即只能读取，不能修改。...
强冲击危险厚煤层孤岛工作面切眼贯通防冲动态调控
07-11
以典型强冲击危险工作面为背景,对孤岛强冲击危险工作面切眼应力进行了分析,在钻屑量、电磁辐射等冲击危险临界指标现场实测基础上,建立多参量冲击危险监测体系并以此指导切眼贯通期间应力控制防冲技术的动态调控。...
精编星火30篇文章贯通考研词汇资料.pdf
10-07
精编星火30篇文章贯通考研词汇资料.pdf 本资源为一份PDF文件，内容为30篇文章，旨在帮助考研学生提高词汇量和阅读理解能力。下面是对该资源的详细知识点解析： 知识点1：词汇扩展 * 许可证（permit）：一种官方...
收藏的30篇文章贯通考研词汇
08-04
【文件名称列表】：虽然没有给出具体的文件名称，但从“30篇文章贯通考研词汇”这个整体名称来看，可以推测每个子文件可能分别代表一篇文章，并且每篇文章都可能围绕一定的主题或话题，利用这些主题来引入和练习相关...
一种高速铁路贯通地线断线故障定位方法
01-13
结合电路和空间电位分布原理，提出了一种高速铁路贯通地线断线故障定位方法。根据扼流变压器的位置对贯通地线进行区段划分，并通过监测信号电缆护层接地电流变化来确定断线区段。向故障区段钢轨首端注入一定电流，...
星火背单词 30篇文章贯通考研词汇
01-14
2006年 星火英语 30篇文章贯通考研词汇 用过的都说好 不下载后悔
C语言_malloc动态开辟内存空间
weixin_54859557的博客
07-10 2975
嵌入式软件开发指南（C语言）
[学习报告]《LeetCode零基础指南》(第4讲)指针（含动态开辟内存）
m0_67739923的博客
04-06 725
文章目录一，指针简单介绍：二，做题记录：三，今日收获 一，指针简单介绍：   指针对于C语言来说可以说是其灵魂所在，指针得存在大大的提升了C语言程序的灵活性和效率等问题，因为它可以直接对指定内存的数据进行访问。指针的内容是十分丰富的，例如：一维数组数组名，二维数组数组名，在使用mallocmallocmalloc等动态开辟内存时候对于指针的操作，指针函数，函数指针，数组指针，指针数组等在此是远远说不完的。本次内容，就在昨天一维数组的基础上，加深一维数组和指针的关系，同时由于LeetCodeLeetCode
初识C语言·动态内存开辟
2301_79697943的博客
01-27 934
3) 对非动态内存开辟的空间释放//对非动态开辟的空间进行释放int main()int a = 10;free(pa);pa = NULL;return 0;前面提到free函数只能释放动态内存开辟的空间，因为局部变量 全局变量是在栈区 静态区的，而free适用于堆区的动态内存开辟，所以使用free释放非动态内存开辟的空间的时候系统就会报错。4）free释放一部分动态内存开辟的空间//使用free释放一部分动态内存开辟的空间int main()assert(p);p++;
【C语言】初识内存开辟/分配
weixin_63449996的博客
04-22 512
提示：这篇文章主要用于自己理解更好的理解内存空间，以便更好的学习C语言的动态内存分配，很多内容资料都来自于其他大佬的博客。 文章目录前言一，内核空间（用户代码不能读写）二，栈区stack（向下增长）三，内存映射四，堆区（向上增长）五，静态区（数据段）六，代码区七，常量区 前言 C/C++程序的内存分配主要有几个区域：内核空间，栈区，堆区，静态区（数据段），常量区，代码区 一，内核空间（用户代码不能读写） 假设有一个4G内存的电脑，那么可能2个G的内存都留给操作系统，内核是操作系统的内部核心程序，它向.
C语言中动态内存管理
qq_44840046的博客
08-20 256
我们已经知道的静态内存开辟方式： 例如：int val =20;// 在栈上开辟四个字节 char arr[10]={0};// 在栈上开辟10个字节的连续空间 上述的开辟内存方式有两个特点： 1)空间开辟的大小是固定的 2）数组在声明的时候，必须指定数组的长度，它所需要的内存在 “编译” 时分配 3）静态内存分配都是在栈上开辟空间 动态内存分配 有些操作对象只在程序运行时才能确定，这...
动态内存开辟详解
cdzg_zzk的博客
03-24 1460
动态内存管理malloc函数代码示例calloc代码实现realloc malloc函数 函数原型 :void* malloc ( size_t size ) 1.如果开辟成功，则返回一个指向开辟好空间的指针。 2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。 3.返回值的类型是 void ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。 4.如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。 注： 1.malloc
营配贯通数据采录工作规范.pdf
11-11
营配贯通数据采录工作规范.pdf营配贯通数据采录工作规范.pdf营配贯通数据采录工作规范.pdf

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Williamtym

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值