动态内存管理（动态内存函数）

已于 2022-12-17 15:05:13 修改
阅读量185 收藏
点赞数 1
文章标签： 算法 c++ java
于 2022-12-16 20:04:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shangguanxiu/article/details/128320896
版权

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

内存的使用方式

  1. 创建变量(开辟一块独立的空间)
    • 局部变量，存在栈区。
    • 全局变量，放静态区。
  2. 创建数组(开辟一块连续的空间)
    • 局部数组-栈区。
    • 全局数组-静态区。

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

  1. 空间开辟的大小是固定的
  2. 数组在定义的时候，必须指定数组的长度，它所需要的内存在编译时分配。

假设我有一个50个坑位的数组int arr[50] = {0}；，如果只用存30个东西进去，剩下20个位置明显就浪费掉了，如果有60则不够存。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了，这时候就只能试试动态内存开辟了，不是所有编译器都支持用变量改变数组元素个数
动态内存分配的好处就是要一块空间就去开辟一块空间，不会造成浪费或坑位不够

2. 动态内存函数

引用头文件<stdlib.h>

2.1 malloc

内存开辟函数

void* malloc (size_t size);

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

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

举个栗子：
向内存申请10个整型的空间

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
        int* p = (int*)malloc(10*sizeof(int));//返回的是void*,要强转

        if(NULL == p)//如果开辟空间失败
        {
                //打印错误原因
                printf("%s\n",strerror(errno));
        }
        else
        {
                //可以正常使用空间
                int i;
                for(i = 0;i < 10;i++)
                {
                        *(p + i) = i;
                        printf("%d ",*(p + i));
                }
                putchar('\n');
        }
        return 0;
}

0 1 2 3 4 5 6 7 8 9

开辟失败的情况

int* p = (int*)malloc(1000000000*sizeof(int));
if(NULL == p)//开辟空间失败
{
		printf("%s\n",strerror(errno));
}

程序执行结果Cannot allocate memory

2.2 free

释放动态开辟的空间

void free (void* ptr);

有借有还，再借不难，free函数是用来释放动态开辟的内存。
当malloc申请的空间不再使用的时候，就应该free给操作系统

  • 要释放哪块空间，就把哪块空间的地址交给free就完事了。
  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  • 如果参数 ptr 是NULL指针，则函数什么事都不做。
  • 在释放内存空间后，所指向的指针要致空，不再使用它。

把p指向的空间还回去
在这里插入图片描述
代码如果还要继续写，但是这块空间不再使用时，自己借的空间应该自己主动free掉，而不是等着return 0帮你还。
注意：此时只是把p指向的那块空间还了回去，但是p还记得之前手里拿的地址，"不法分子"利用p还是能找到那块空间，所以主动点，动动发财的小手p = NULL

2.3 calloc

开辟一块空间，并将元素初始化成0。

void* calloc (size_t num, size_t size);

  • void* calloc (元素个数, 每个元素的大小);
  • 为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
  • 与函数 malloc 的唯一区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
  • 开辟成功，返回地址，开辟失败，返回NULL

举个栗子：
开辟一个40个字节的空间

malloc(10 * sizeof(int));
calloc(10 , sizeof(int));

calloc开辟空间的同时全部初始化为0

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

int main()
{

        int* p = (int*)calloc(10,sizeof(int));
        if(NULL == p)
        {
                printf("%s",strerror(errno));
        }
        else
        {
                int i;
                for(i = 0;i < 10;i++)
                {
                        printf("%d ",*(p + i));
                }
                putchar('\n');
        }

        free(p);//用完才释放
        p = NULL;

        return 0;
}

0 0 0 0 0 0 0 0 0 0

和mallloc的区别也就只有malloc不初始化，calloc全部初始化为0而已。

2.4 realloc

调整动态开辟内存空间的大小
有时候觉得开辟的空间不够了，要增加一些，有时候又多了要减少一点，这时候就要用到realloc函数来调整开辟的空间。

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

  • ptr 是要调整的内存地址
  • size 调整之后新大小
  • 返回值为调整之后的内存起始位置。
  • 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
  • 如果追加空间失败，会返回NULL。

举个栗子

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

int main()
{
		int i;
	
		int* p = (int*)malloc(20);
		if(NULL == p)
		{
			printf("%s\n",strerror(errno));
		}
		else
		{
			printf("调整前:");
			for(i = 0;i < 5;i++)
			{
				*(p + i) = i;
				printf("%d ",*(p + i));
			}
			putchar('\n');
		}
		int* pp = (int*)realloc(p,40);//改p指向的空间为40字节
		if(NULL != pp)//追加空间如果失败会返回NULL，如果用p来接收，会导致原来p指向的20个字节的空间也找不到了
		{	//所以先用一个新的指针变量接收，来判断是不是NULL
			p = pp;
		}
		printf("调整后:");
		for(i = 5;i < 10;i++)
		{
			*(p + i) = i;
		}
		for(i = 0;i < 10;i++)
		{
			printf("%d ",*(p + i));
		}
		putchar('\n');	
		free(p);
		p = NULL;
		return 0;
}

调整前:0 1 2 3 4 
调整后:0 1 2 3 4 5 6 7 8 9

realloc在调整内存空间时存在两种情况：

  • 情况1：原有空间之后有足够大的空间，扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化，返回旧地址。
  • 情况2：原有空间之后没有足够大的空间，没有足够的空间时总不能去抢别人的地盘吧，realloc会重新找一个内存区域开辟一块符合要求的空间，返回新地址，拷贝旧数据，free旧空间。

不管情况1还是2，用完动态开辟的内存之后都应该主动free掉
在这里插入图片描述

利用realloc开辟动态空间

void * realloc (NULL, size_t size);

举个栗子：

int* p = (int*)realloc(NULL,40);//效果等于malloc(40)

3. 常见动态内存错误

3.1 对NULL指针的解引用操作

万一开辟空间失败了，返回来个NULL，对接收NULL的指针进行解引用就会导致程序崩溃。

		int* p = (int*)malloc(40);
        //万一malloc开辟空间失败了,p就被赋值为NULL

        int i;
        for(i = 0;i < 10;i++)
        {
                //这里就会变成对NULL指针的解引用
                *(p + i) = i;
        }
        free(p);
        p = NULL；

所以在使用动态开辟的空间之前，一定要先判断指针是否为NULL。

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

		int* p = (int*)malloc(5*sizeof(int));
        if(NULL == p)
        {
                printf("%s\n",strerror(errno));
        }
        else
        {
                int i;
                for(i = 0;i < 10;i++)//这块空间只有20个字节，却要使用40个字节
                {
                        *(p + i) = i;
                        printf("%d ",*(p + i));
                }
                putchar('\n');
        }

        free(p);
        p = NULL;

程序直接崩溃
在这里插入图片描述

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

		int  a = 10;
        int* pa= &a;

        free(pa);
        pa = NULL;

程序照样崩溃
在这里插入图片描述

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

int* p = (int*)malloc(40);

        if(NULL == p)
        {
                return 0;
        }
        else
        {
                int i;
                for(i = 0;i < 10;i++)
                {
                        *p++ = i;
                }
        }
        //回收空间
        free(p);
        p = NULL;

直接崩溃

7fff475e7000-7fff475e9000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
已放弃(吐核)

因为p不再指向动态内存的起始地址
在这里插入图片描述

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

		int* p = (int*)malloc(40);
        if(NULL == p)
        {
                return 0;
        }
        else
        {
                int i;
                for(i = 0;i < 10;i++)
                {
                        *(p + i) = i;
                }
        }
        free(p);
        //....代码写着写着忘记p已经释放过一次了,于是
        free(p);

程序依然崩溃

7fff475e7000-7fff475e9000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
已放弃(吐核)

解决方法：在第二次释放之前，将p转换为空指针，再释放，就没有问题了，
所以free掉一块空间之后立刻将指针置为NULL是很有必要的。

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

只借不还，不停的开辟开辟压根不带还的

		 while(1)
        {
                malloc(1);//不停的开辟一个字节的空间
        }

已杀死

疯狂的开辟内存然后被计算机自动干掉了

4. 小试牛刀

4.1 题目1

运行Test后会发生什么？

void GetMemory(char *p)
{
		p = (char *)malloc(100);
}
void Test(void)
{
		char *str = NULL;
		GetMemory(str);
		strcpy(str, "hello world");
		printf("%s\n",str);
}

1. 运行代码时会出现崩溃的情况。
2. 程序存在内存泄露。

在这里插入图片描述
改正方法1

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

void Test(void)
{
        char *str = NULL;

        GetMemory(&str);
        strcpy(str, "hello world");
        printf("%s\n",str);
        free(str);
        str = NULL;
}

hello world

改正方法2
让p这个临时变量，在临死之前把它手里记住的地址交给str

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

void Test(void)
{
        char *str = NULL;

        str = GetMemory(str);
        strcpy(str, "hello world");
        printf("%s\n",str);
        free(str);
        str = NULL;
}

别忘了在开辟空间之后，str还是有可能为NULL，记得判断

4.2 题目2

问题出在哪？

#include <stdio.h>
char *GetMemory(void)
{
        char p[] = "hello world";
        return p;
}
void Test(void)
{
        char *str = NULL;
        str = GetMemory();
        printf("%s\n",str);
}
int main()
{
        Test();
        return 0;
}

非法访问内存，输出了个随机值

警告：函数返回局部变量的地址 [-Wreturn-local-addr]
  return p;
  ^
 ��P�

因为数组p是局部变量，放在栈区，出了p所在的函数，p的内容会被销毁，这块空间还回去了，再拿着p的地址找回去，找到的就不知道是啥了。栈空间上的地址不要随便返回

解决方法1：
加个static，延长局部变量的生命周期，把p放到静态区，让p出了函数之后不被销毁。

static char p[] = "hello world";

解决方法2
让hello world变成一个常量字符串，放在只读数据区

 char* p = "hello world";

4.3 题目3

Test运行之后发生什么？

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

可以正常打印，但是str用完之后没有主动free，存在内存泄露

4.4 题目4

运行Test后会发生什么？

void Test(void)
{
        char *str = (char *) malloc(100);
        strcpy(str, "hello");
        free(str);//free释放str指向的空间之后，并不会把str置为NULL
        if(str != NULL)//那么这个判断就没有意义了
        {
                strcpy(str, "world");//还将world拷到原来的那块空间属于非法访问
                printf(str);
        }
}

打印出world

但是，存着hello的那块空间已经被free掉，这块空间不再属于str，但是str任然记得这块空间的地址，将world拷到str属于非法访问内存，（酒店退房之后，但是还记得房间号，硬要用这个房间，非法访问了）

实际考察free掉str后，str成了个野指针，并不会变成空指针，那么if里的判断条件就没意义了

void Test(void)
{
        char *str = (char *) malloc(100);
        strcpy(str, "hello");
        free(str);
        str = NULL;
        if(str != NULL)//将str置为NULL后，这个判断才有意义
        {
                strcpy(str, "world");//还将world拷到原来的那块空间属于非法访问
                printf(str);
        }
}

5. 柔性数组

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

举个栗子：

typedef struct student
{
        int a;
        int b[];//未知大小的-柔性数组成员-数组的大小是可以调整的
}stu;

编译是能通过的

有些编译器可能无法编译，可以改成

typedef struct student
{
        int a;
        int b[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
}stu;

5.1 柔性数组的特点

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

举个栗子

typedef struct student
{
        int a;
        int b[0];//柔型数组成员
}stu;
int main()
{
        stu s;
        printf("s = %d\n",sizeof(s));
        return 0;
}

s = 4

可以看到，结构体的大小并没有包含柔性数组的大小.

5.2 柔性数组的使用

给柔性数组成员开辟5个整型的空间：

typedef struct student
{
        int a;
        int b[];
}stu;
int main()
{
        stu* ps = (stu*)malloc(sizeof(stu) + 5 * sizeof(int));
        return 0;
}

因为结构体大小是4字节，给结构体追加的20个字节就是给柔性数组开辟的字节。
此时总开辟空间大小就是（结构体大小+给柔性数组单独开辟的空间大小）
在这里插入图片描述
代码1

typedef struct student
{
        int a;
        int b[0];
}stu;
int main()
{
        stu* ps = (stu*)malloc(sizeof(stu) + 5 * sizeof(int));//给柔性数组开辟了5个整型的空间
        ps -> a = 100;
        int i;
        for(i = 0;i < 5;i++)
        {
                ps -> b[i] = i;//将前5个元素赋值0 1 2 3 4
        }
        stu* pa = realloc(ps,44);//将柔性数组的大小调整为10个整型
        if(NULL != pa)
        {
                ps = pa;
        }
        for(i = 5;i < 10;i++)
        {
                ps -> b[i]= i;
        }
        for(i = 0;i < 10;i++)
        {
                printf("%d ",ps -> b[i]);
        }
        printf("\na = %d\n",ps -> a);
        free(ps);
        ps = NULL;
        return 0;
}

0 1 2 3 4 5 6 7 8 9 
a = 100

5.3 柔性数组的优势

上面的代码1也可以改成这个样子

代码2


typedef struct student
{
        int a;
        int* b;
}stu;

int main()
{
        stu* ps = (stu*)malloc(sizeof(stu));
        ps -> b = malloc(5 * sizeof(int));
        ps -> a = 100;

        int i;
        for(i = 0;i < 5;i++)
        {
                ps -> b[i] = i;
                printf("%d ",ps -> b[i]);
        }
        putchar('\n');

        //调整大小
        int* ptr = realloc(ps -> b,10*sizeof(int));
        if(NULL != ptr)
        {
                ps -> b = ptr;
        }
        for(i = 5;i < 10;i++)
        {
                ps -> b[i] = i;
        }
        for(i = 0;i < 10;i++)
        {
                printf("%d ",ps -> b[i]);
        }
        printf("\na = %d\n",ps -> a);

        free(ps -> b);
        ps -> b = NULL;
        free(ps);
        ps = NULL;
        return 0;
}

0 1 2 3 4 
0 1 2 3 4 5 6 7 8 9 
a = 100

代码1和代码2可以完成同样的功能，代码1(柔性数组)相对于方法2的优势。

  • 优势1：方便内存释放
    • 代码2中使用了两次malloc，所以就得进行两次free。
    • malloc用的越多，free也就用的越多。
    • free少了会导致内存泄露，free的先后顺序错了，也会导致出问题。
  • 优势2 有利于访问速度.
    • 连续的内存有益于提高访问速度，也有益于减少内存碎片。
    • 多次使用malloc会导致到处开辟空间，内存碎片多了后其他东西可能就不够位置放了。
    • 这里挖一个坑，那里挖一个坑，挤的别人只能在夹缝里里找空间存放东西
    • 在这里插入图片描述
♬咖啡猫♬
关注
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
linux 已放弃(吐核) (core dumped) 问题分析
豆芽菜
05-25 3270
在运行自己写的 C多线程程序时，出现：已放弃(吐核) 问题。 出现这种问题一般是下面这几种情况： 1.内存越界 2.使用了非线程安全的函数 3.全局数据未加锁保护 4.非法指针 5.堆栈溢出 也就是需要检查访问的内存、资源。 可以使用 strace命令来进行分析 在程序的运行命令前加上 strace，在程序出现：已放弃（吐核），终止运行后，就可以通过 strace打印在控制台的跟踪信息进行分析和定位问题。 上面打印出了程序出错的原因：程序中重复 fre...
Linux centos7 代码运行时出现已放弃（吐核）的问题解决
hu_yinghui的博客
05-10 4125
代码环境： linux centos7系统 conda环境 GPU运行 问题描述 在运行时出现下图问题： 原因分析： 应该是上一个程序进程没有结束，占用了显存，导致显存没有释放。 解决方案： 通过命令找到该进程 找到进程的PID 杀掉该进程 kill -9 PID（kill -9 2466） 重新运行 解决吐核问题 ...
C++vector容器用法详解
最新发布
天道酬勤
04-01 3526
vector 是封装动态数组的顺序容器，连续存储数据，所以我们不仅可以通过迭代器访问存储在 vector 容器中的数据，还能用指向 vector 容器中的数据的常规指针访问数据。这意味着指向 vector 容器中的数据的指针能传递给任何期待指向数组元素的指针的函数。
Linux查看放弃吐核文件
醉梦流星雨
11-10 786
ulimit -c unlimited 然后通过gdb的bt指令查看函数调用栈
动态内存分配函数解析
11-09
本文主要讲解了四个关键的动态内存管理函数：malloc, calloc, realloc 和 memset。理解并正确使用这些函数是编写高效且安全的代码的关键。 首先，`malloc()` 函数是最基本的动态内存分配工具。它的原型是 `Void *...
通讯录管理-动态内存.zip
07-09
在IT领域，动态内存管理是编程中的一个关键概念，特别是在C语言中，它允许程序员在程序运行时根据需要分配和释放内存。在这个“通讯录管理-动态内存.zip”项目中，开发者显然使用了C语言来创建一个通讯录管理程序，...
浅谈在函数中返回动态的内存
08-31
总的来说，正确处理函数中返回的动态内存涉及到对指针、引用和内存管理的理解。在实际编程中，推荐使用智能指针（如`std::unique_ptr`或`std::shared_ptr`）来自动管理动态内存，以减少手动管理内存时可能出现的错误...
Malloc动态内存申请函数
06-20
在C语言编程中，动态内存管理是一项至关重要的技能。malloc函数是C标准库提供的一种动态内存分配的方式，允许程序在运行时根据需要申请内存空间。本文将深入探讨malloc函数的工作原理及其在实际项目中的应用。 ...
虚拟机中oracle监听，包括dbca和netca的图形界面无法启动
applenet555的博客
03-11 1073
虚拟机中oracle监听，包括dbca和netca无法启动 事情的简单过程： vmware虚拟机将虚机挂起（挂起状态） 打开虚拟机，vmware提示开始还原虚拟机 还原完毕，虚拟机启动正常 启动oracle数据库正常 启动监听失败 启动netca和dbca的图形界面失败，报错如下： Oracle Net Services 配置: #A fatal error has been detecte...
Linux下如何发布Qt程序
晓阳 的专栏
06-20 918
在X11平台下qt程序，首先准备好程序中需要使用的资源，库和插件...     比如你的可运行程序取名叫作panel，那把你的panel,那些libQt*.so.4和libQt*.so.4.6.0（链接和共享库都要）放在同一目录下(也可以不同,只要小小修改下shell文件).plugins就不多说了。     在程序的同目录下，新建一個空文档，取名panel.sh (文件名与程序名同名,扩展名
Linux：进程信号
碧瑶的博客呀
11-01 210
信号入门 概念 信号是一种操作系统与进程之间某些事件发生的通知机制，具有随机性（异步），进程后续必定要认识信号，知道信号怎么处理，操作系统向进程发信号（操作系统是进程的管理者，可以向进程发信号），就是操作系统找到目标进程PCB，然后修改PCB中位图中的比特位，由0置1，因此这种说法不正确，而应该叫做操作系统向进程写信号（但是一般还是采用前面那种叫法）；当获取一个信号时，并不一定会立即做这件事情，...
free函数在操作系统内存中的实现
Miibotree
10-15 4494
昨天在写单项链表的时候碰到这样一个问题。 我一次性malloc十个单位节点的内存空间出来赋值给L， 现在我想一次性删除从第3个到第6个节点，我是这么做的： 1.将第六个节点的next指针指向NULL 2.将L指针指向第三个单位空间的地址，再free(L)。 等到把代码写完之后，才发现其中的问题：这里我的free(L)用的对吗？ 编译运行了一下才发现了问题所在。 为了清楚地看到这
linux 已放弃(吐核) (core dumped) 问题分析
ajiong0126的博客
10-17 3994
在运行自己写的 C多线程程序是，出现：已放弃(吐核) 问题。 出现这种问题一般是下面这几种情况： 1.内存越界 2.使用的非线程安全的函数 3.全局数据未加锁保护 4.非法指针 5.堆栈溢出 也就是需要检查访问的内存、资源。 可以使用 strace命令来进行分析 在程序的运行命令前加上 strace，在程序出现：已放弃（吐核），终止运行后，就可以通过 ...
linux 使用双目相机问题总结（一）：已放弃（核心已转储）
浅眠忘川的博客
08-30 2926
如果出现： *** Check failure stack trace: ***     @     0x7ff7320d9daa  (unknown)     @     0x7ff7320d9ce4  (unknown)     @     0x7ff7320d96e6  (unknown)     @     0x7ff7320dc687  (unknown)     @     0x7f...
Tensorflow错误：非法指令(吐核)
Science Evan Blog
08-15 4228
非法指令(吐核) 原因分析： tensorflow版本和操作系统版本不兼容，用版本相对老的tensorflow 解决方案 安装tensorflow==1.5.0为例: pip install -i https://pypi.douban.com/simple tensorflow==1.5.0 参考：https://blog.csdn.net/xuefeng1207/article/detai...
java吐核_程序运行提示 退出(吐核)
weixin_39725365的博客
02-12 398
/* sigactdemo.c* purpose: shows use of sigaction()* feature: blocks ^\ while handling ^C* does not reset ^C handler, so two kill*/#include #includ...
C++动态内存与析构函数详解
总结来说，理解和掌握动态内存分配、析构函数和拷贝赋值操作符对于编写高效、健壮的C++代码至关重要，它们共同构成了内存管理和对象生命周期管理的核心部分。在实际编程中，这些概念不仅应用于基础的数据结构（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值