013+limou+C语言深入知识——（5）动态内存管理以及分配

已于 2023-06-15 21:01:01 修改
阅读量530 收藏 1
点赞数 2
分类专栏： C语言（第一版） 文章标签： c语言 c++ 开发语言
于 2023-03-28 15:51:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73168361/article/details/129817299
版权

000、简易的C语言变量视角空间申请图示

  • 局部变量、函数形式参数在栈区申请内存空间
  • 动态内存在堆区申请内存空间
  • 静态变量、全局变量在静态区申请内存空间

在这里插入图片描述

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

（1）之前创建空间的方法

int a = 10;//在栈空间开辟4个字节
int arr[10];//在栈空间开辟4*10个字节
  • 可以看到这样开辟的空间是无法修改大小的，数组也必须指定其长度，其所需内存在“编译时”分配
  • 而有的时候需要在程序运行的时候才能知道所需空间大小，这样就需要动态分配内存了

（2）动态内存分配的相关函数

002、动态内存函数

（1）malloc和free

void* malloc (size_t size);
void free (void* ptr);

  • malloc函数的功能是先向内存申请一块连续可用的空间，并且返回指向这块空间的地址

    • 如果开辟空间失败，就返回一个NULL，为了避免解引用空指针，所以一般都要对malloc的返回值做检查
    • malloc的返回值是void*，malloc并不知道使用者需要开辟空间的类型，在使用malloc的时候由使用者决定指针类型，通常使用强制类型转换来转化
    • 参数size的值为0，其结果是未知的（C标准没有对此进行定义），要看编译器的具体实现（另外这种需求也很奇怪：如果说要开辟空间，又想得到0个空间，这是很矛盾的）
    • 注意size是以字节为单位申请空间的

  • free函数的功能是将某个指针指向的动态内存释放掉

    • 通常释放掉某个指针指向的动态内存后，要将该指针置空，避免其成为空指针
//例子一
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    //1.申请动态内存
    int* a = (int*)malloc(sizeof(int));
    if(a == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //2.使用动态内存
    *a = 5;
    printf("在%p地址处存储了数值:%d\n", a, *a);

    //3.释放动态内存
    free(a);//释放动态内存
    a = NULL;//置空，避免野指针的出现
    return 0;
}

//例子二
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NUMBER 10
int main()
{
    //1.申请动态内存
    int* arr = (int*)malloc(sizeof(int) * NUMBER);
    if(arr == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //2.使用动态内存
    for(int i = 0; i < NUMBER; i++)
    {
        arr[i] = i + 1;
    }

    for(int i = 0; i < NUMBER; i++)
    {
        printf("%d ", arr[i]);
    }

    //3.释放动态内存
    free(arr);//释放动态内存
    arr = NULL;//置空，避免野指针的出现
    return 0;
}

（2）calloc

void* calloc (size_t num, size_t size);
  • 函数的功能是为num个大小为size的元素开辟一块连续可用的空间，并且把空间的每个字节都初始化为0
  • 与malloc的区别
    • calloc会在返回地址之前，把申请空间的每个字节都初始化为全0
    • 同时注意该函数参数的参数设计和malloc不太一样
    • 若是calloc的参数num==1，则后面参数就和malloc是一样的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NUMBER 10
int main()
{
    //1.申请动态内存
    int* arr = (int*)calloc(NUMBER, sizeof(int));//注意参数设计有点不太一样
    if (arr == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //2.使用动态内存
    for (int i = 0; i < NUMBER; i++)
    {
        printf("%d ", arr[i]);
    }

    //3.释放动态内存
    free(arr);//释放动态内存
    arr = NULL;//置空，避免野指针的出现
    return 0;
}

（3）realloc

void* realloc (void* ptr, size_t size);
  • 该函数的功能是可以灵活调整“由malloc/calloc开辟的动态内存空间”的大小
    • ptr是要调整的内存地址，size是调整之后新大小，返回值为调整之后的内存起始位置。
    • 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
    • realloc调整内存空间的时候存在两种情况：
      • 情况1：原有空间后面若有足够大的空间，要扩展内存就直接在原有内存后追加空间，原有空间的数据不发生变化
      • 情况2：原有空间后面若无足够大的空间，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的将会是一个新的内存地址
  • 因此对realloc函数的使用，其返回值是需要极其注意的
  • 如果realloc申请空间变小，则多余的空间就会自动还给操作系统
  • 另外realloc是可以替代malloc函数的，即：如果第一个参数是一个空指针的话，就可以跟malloc一个效果
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NUMBER 10
int main()
{
    //1.申请动态内存
    int* arr = (int*)malloc(NUMBER * sizeof(int));//注意参数设计有点不太一样
    if (arr == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //2.使用动态内存
    //①输入数据
    for (int i = 0; i < NUMBER; i++)
    {
        arr[i] = i * i;
    }
    //②打印数据
    for (int i = 0; i < NUMBER; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");

    //3.再次扩大动态内存
    int* arr1 = realloc(arr, sizeof(int) * (NUMBER + 10));
    if (arr1 == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //4.使用扩大后的动态内存
    //①查看原数据是否还存在
    for (int i = 0; i < NUMBER; i++)
    {
        printf("%d ", arr1[i]);
    }
    //②查看是否可以在新申请的空间赋予新的数据
    for (int i = NUMBER; i < NUMBER + 10; i++)
    {
        arr1[i] = i * i;
    }
    printf("\n");
    for (int i = 0; i < NUMBER + 10; i++)
    {
        printf("%d ", arr1[i]);
    }

    //5.释放动态内存
    free(arr1);//释放动态内存
    arr1 = NULL;//置空，避免野指针的出现
    return 0;
}

//如果为了代码的变量统一性，也可以这么做
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NUMBER 10
int main()
{
    //1.申请动态内存
    int* arr = (int*)malloc(NUMBER * sizeof(int));//注意参数设计有点不太一样
    if (arr == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }

    //2.使用动态内存
    //①输入数据
    for (int i = 0; i < NUMBER; i++)
    {
        arr[i] = i * i;
    }
    //②打印数据
    for (int i = 0; i < NUMBER; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");

    //3.再次扩大动态内存
    int* arr1 = realloc(arr, sizeof(int) * (NUMBER + 10));
    if (arr1 == NULL)//对返回值指针进行检查
    {
        printf("申请失败\n");
        printf("%s\n", strerror(errno));
        exit(-1);//或者return 1;
    }
    else
    {
        arr = arr1;//这样后面的代码就会统一一些，这其实没有太大问题，尽管编译器还是有可能报警告
    }

    //4.使用扩大后的动态内存
    for (int i = NUMBER; i < NUMBER + 10; i++)
    {
        arr[i] = i * i;
    }
    printf("\n");
    for (int i = 0; i < NUMBER + 10; i++)
    {
        printf("%d ", arr[i]);
    }

    //5.释放动态内存
    free(arr1);//释放动态内存
    arr1 = NULL;//置空，避免野指针的出现
    return 0;
}

在这里插入图片描述

003、常见的动态内存错误

（1）对NULL指针的解引用操作

#include <stdlib.h>
void test()
{
    int *p = (int*)malloc(4);//申请4个字节
    *p = 20;//如果malloc申请失败，则p的值是NULL，则这里就会出现对空指针的解引用
    free(p);
}
int main()
{
    test();
    return 0;
}

在这里插入图片描述

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

#include <stdlib.h>
void test()
{
    int i = 0;
    int *p = (int*)malloc(10 * sizeof(int));
    if(NULL == p)
    {
        return 1;
    }
    for(i=0; i<=10; i++)
    {
        *(p+i) = i;//当i等于10的时候就发生越界访问
    }
    free(p);
}
int main()
{
    test();
    return 0;
}

在这里插入图片描述

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

void test()
{
    int a = 10;
    int *p = &a;
    free(p);//释放了非动态内存
}
int main()
{
    test();
}

在这里插入图片描述

（4）使用free释放一块动态内存的一部分

#include <stdlib.h>
void test()
{
    int *p = (int*)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置
}
int main()
{
    test();
    return 0;
}

在这里插入图片描述

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

void test()
{
    int *p = (int *)malloc(100);
    free(p);
    free(p);//重复释放了该指针，但是有一个解决方案就是将已经释放的指针置空，free(NULL)不会产生任何效果，这样即使多次释放也没关系
}
int main()
{
    test();
    return 0;
}

在这里插入图片描述

（6）动态开辟内存忘记释放（内存泄漏，在工程中属于比较严重的问题）

  • 注意以下代码不能运行太久，不然有可能你的计算机会变“卡”，不过现在大多数系统都会对此做保护
#include <stdlib.h>
#include <windows.h>
int main()
{
    while (1)
    {
        int* p = (int*)malloc(100);
        Sleep(1000);
    }
}

004、经典题目

（1）题目一：没有正确区分栈内存和堆内存

void GetMemory(char *p) 
{
    p = (char*)malloc(100);//这个p出了这个函数就再也找不到了，会一直内存泄漏，没有机会释放
}
void Test(void)
{
    char *str = NULL;
    GetMemory(str);//而且p没有被带回来，这里的str应该是传指针变量的地址，而不是传指针变量本身的值，因此strcpy会解引用空指针
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

//上述代码应该修改如下
#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;
}

（2）题目二：返回栈空间地址错误

char *GetMemory(void) 
{
    char p[] = "hello world";//局部变量除了出了该函数会被销毁，无法像动态内存一样被带回
    return p; 
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();//带回来了一个野指针
    printf(str);
}

（3）题目三：忘记使用free

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

005、C/C++程序的内存开辟（开头的三区是以下的简化版，两者是包含关系）

（1） 使用柔性数组的方法

//code1
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
typedef struct limou
{
    int n;
    char c;
    int arr[0];
}limou;
int main()
{
    //申请结构体内存
    limou* plimou = (limou*)malloc(sizeof(limou) + 5 * sizeof(int));
    if (plimou == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }

    //使用柔性数组的内存
    for (int i = 0; i < 5; i++)
    {
        plimou->arr[i] = i;
        printf("%d ", plimou->arr[i]);
    }
    printf("\n");

    //调增柔性数组的大小
    limou* plimou1 = realloc(plimou, sizeof(limou) + 10 * sizeof(int));
    if (plimou1 == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    for (int i = 5; i < 10; i++)
    {
        plimou1->arr[i] = i;
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", plimou1->arr[i]);
    }

    free(plimou1);
    plimou1 = NULL;
    return 0;
}

（2）柔性数组的另一种等价实现

柔性数组使得结构体的内存是可变的，当然，这种场景下，在C99之前还有一种解决方案

//code2
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
typedef struct limou
{
    int n;
    char c;
    int* arr;
}limou;
int main()
{
    limou* plimou = (limou*)malloc(sizeof(limou));
    if (plimou == NULL)
    {
        perror("malloc1");
        return 1;
    }
    int* ptr = (limou*)malloc(sizeof(int) * 10);
    if (ptr == NULL)
    {
        perror("malloc2");
        return 1;
    }
    else
    {
        plimou->arr = ptr;
    }

    //使用动态内存
    for (int i = 0; i < 10; i++)
    {
        plimou->arr[i] = i * i;
        printf("%d ", plimou->arr[i]);
    }

    //调整内存大小
    ptr = realloc(plimou->arr, 20 * sizeof(int));
    if (ptr == NULL)
    {
        perror("malloc3");
        return 1;
    }
    else
    {
        plimou->arr = ptr;
    }

    printf("\n");
    //使用调整后内存
    for (int i = 0; i < 20; i++)
    {
        plimou->arr[i] = i * i;
        printf("%d ", plimou->arr[i]);
    }

    //两次释放内存
    free(plimou->arr);
    plimou->arr = NULL;
    free(plimou);
    plimou = NULL;
    return 0;
}

（3）对比两种实现的优缺点

  • 出错概率：code2方法需要多次free，从次数上来讲，这种方法比较容易出错，code1柔性数组的实现更加简单
  • 使用频率：只可惜现在code1中的柔性数组的普及力还不够大，往往较为少用
  • 内存碎片：在code2中，多次malloc生成的空间大概率是不连续的，申请的越多，内存碎片就会增多，内存使用率就会降低，而code1就会提高内存使用效率
  • 访问速度：由于是code1中申请的内存是连续的，可以提高访问效率（不是特别明显）

（4）有关柔性数组拓展阅读

C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell

limou3434
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言全局静态申请int,C语言学习--全局变量、静态本地变量
weixin_33701379的博客
05-23 305
全局变量全局变量定义在函数外面的变量是全局变量全局变量具有全局的生存期和作用域它们与任何函数无关在任何函数内部都可以使用它们#include int f(void);int gAll = 12;intmain(){printf("gAll in %s function is %d\n",__func__,gAll); //注意：__func__是输出是哪个函数，下划线是两个连着一起f();pr...
c语言内存管理及动态内存申请
qq_46135211的博客
02-26 1217
c语言内存管理及动态内存申请 栈区 \ 堆区 \ 未初始化数据区 \ 初始化数据区 \ 代码区
变量和内存
Mr.魏
11-06 956
全局和局部变量 1、局部变量作用域：从创建到所在函数结束 2、如果在函数中 函数创建顺序从右往左 打印变量地址结果：从高向低增长 注意：不同函数中变量名可以一样，其所对应的地址不一样； 3、全局变量：作用在整个项目中，使用的前提是需要在使用的文件中进行声明 4、声明变量就是可以使用这个变量，声明不会分配内存空间 注意：如果在函数外部是全局变量 在函数外面是局部变量 如果全局变量写在主函数...
全局变量与静态变量
TABE_的博客
12-23 7840
这里写目录标题局部变量全局变量静态局部变量静态全局变量 局部变量 局部变量具有局部作用域。他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用结束后，变量就被撤销，其所占用的内存也被收回。生命周期在函数结束后就结束了，作用域也仅限于该函数。 全局变量 全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包括全局变量定义的源文件需要用extern关键字再次声明这个全局变量。 静态局部变量 静态局部变量具有局部作用域。它只被初始化一次，自
014+limou+C语言深入知识——（6）文件操作
limou3434的博客
03-31 464
主要讲解了文件操作相关的函数和概念
010+limou+C语言深入知识——（2）指针的深入理解
limou3434的博客
02-26 602
指针的深入理解，本文介绍了C语言中，指针至少要知道的一些概念
006+limou+C语言入门知识——（5）指针
limou3434的博客
04-05 629
主要讲解的指针的初阶应用和概念
015+limou+C语言深入知识——（7）编译环境和运行环境以及预处理指令
limou3434的博客
04-04 727
主要讲解了C语言的编译环境、运行环境以及部分预处理指令
C语言free()函数：释放动态分配的内存空间
07-17 2624
头文件：#include int a[10]; // ... free(a);如果 ptr 所指向的内存空间不是由上面的三个函数所分配的，或者已被释放，那么调用 free() 会有无法预知的情况发生。如果 ptr 为 NULL，那么 free() 不会有任何作用。注意：free() 不会改变 ptr 变量本身的值，调用 free() 后它仍然会指向相同的内存空间，但是此时该内存已无效，不能被使用。所
Java的c/s架构如何同时访问多个数据源
codemami的博客
06-11 1145
在Java的客户端/服务器（C/S）架构中，当服务器需要同时访问多个数据源时，通常是在服务器端进行配置和实现的。可以通过继承这个类来自定义多数据源的连接。在Java的C/S（客户端/服务器）架构中，实现同时访问多个数据源通常涉及后端服务器的设计和实现。接下来，你需要实现一个动态数据源路由的功能，这通常是通过继承AbstractRoutingDataSource类来实现的。配置数据源：为每个数据源创建DataSource对象，并配置相应的数据库连接信息，如驱动类名、URL、用户名和密码等。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1041
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C的I/O操作
weidl001的博客
06-17 563
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
【c++进阶(三)】STL之vector的介绍和使用
weixin_62196764的博客
06-15 836
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
11.5.k8s中pod的调度-cordon，drain，delete
最新发布
qq_22321199的专栏
06-17 441
-ignore-daemonsets #daemonset资源不能被驱逐，需要排除，加这个选项参数排除；--delete-emptydir-data #如果无法驱逐成功，再加这个参数；
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 剩余银饰的重量(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-17 73
K小姐从二手市场收集了 NNN 块银饰，每块银饰的重量都是正整数。这些银饰会被熔化用于打造新的饰品。每一回合，K小姐会选出三块最重的银饰一起熔掉。假设银饰的重量分别为 xxx、yyy 和 zzz，且 x≤y≤zx \\le y \\le zx≤y≤z。那么熔掉的可能结果如下： 1\. 如果 x\=y\=zx = y = zx\=y\=z，那么三块银饰都会被完全熔掉。 2\. 如果 x\=yx = yx\=y 且 y≠zy \\ne zy̸\=z，会剩余重量为 z−yz - yz−y 的银块无法被熔掉。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 415
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 306
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
C语言快速排序的具体实现
03-30
快速排序是一种常用的排序算法，其基本思想是通过一趟排序将待排序数组分割成两个部分，其中一部分的所有元素都比另一部分小，然后再对这两部分分别进行快速排序，以达到整个序列有序的目的。 快速排序的具体实现如下： 1. 选取一个基准数，一般选择第一个数或最后一个数作为基准数。 2. 从序列右端开始向左扫描，找到第一个比基准数小的数，将其与基准数交换。 3. 从序列左端开始向右扫描，找到第一个比基准数大的数，将其与基准数交换。 4. 重复上述两步操作，直到左右指针相遇。 5. 将基准数左边的序列和右边的序列分别递归地进行快速排序。 C语言代码实现如下： ``` void quickSort(int arr[], int left, int right) { int i, j, temp, pivot; if (left < right) { i = left; j = right; pivot = arr[left]; // 选取第一个数为基准数 while (i < j) { // 从右向左找第一个小于基准数的数 while (i < j && arr[j] >= pivot) { j--; } // 从左向右找第一个大于基准数的数 while (i < j && arr[i] <= pivot) { i++; } // 交换两个数 if (i < j) { temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 将基准数归位 arr[left] = arr[i]; arr[i] = pivot; // 递归调用左右两边的序列 quickSort(arr, left, i - 1); quickSort(arr, i + 1, right); } } ``` 调用方法如下： ``` int main() { int arr[] = {3, 5, 1, 4, 2, 6, 8, 7}; int len = sizeof(arr) / sizeof(int); quickSort(arr, 0, len - 1); for (int i = 0; i < len; i++) { printf("%d ", arr[i]); } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

limou3434

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

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

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

打赏作者

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

抵扣说明：

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

余额充值