C和汇编---数组

最新推荐文章于 2022-04-15 21:17:38 发布
最新推荐文章于 2022-04-15 21:17:38 发布
阅读量435 收藏 2
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41683305/article/details/104620138
版权
0x01 初始化数组

1、没有初始化数组

#include "stdio.h"
int main(void)
{
	int data[4];
	for (int i=0;i<4;i++)
	{
		printf("%d\t",data[i]);
	}
	
	return 0;
}

不同系统，输出结果可能不一样：
在这里插入图片描述
反汇编：

4:        int data[4];
5:        for (int i=0;i<4;i++)
00401028 C7 45 EC 00 00 00 00 mov         dword ptr [ebp-14h],0
0040102F EB 09                jmp         main+2Ah (0040103a)
00401031 8B 45 EC             mov         eax,dword ptr [ebp-14h]
00401034 83 C0 01             add         eax,1
00401037 89 45 EC             mov         dword ptr [ebp-14h],eax
0040103A 83 7D EC 04          cmp         dword ptr [ebp-14h],4
0040103E 7D 17                jge         main+47h (00401057)
6:        {
7:            printf("%d\t",data[i]);
00401040 8B 4D EC             mov         ecx,dword ptr [ebp-14h]
00401043 8B 54 8D F0          mov         edx,dword ptr [ebp+ecx*4-10h]
00401047 52                   push        edx
00401048 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040104D E8 3E 00 00 00       call        printf (00401090)
00401052 83 C4 08             add         esp,8
8:        }
00401055 EB DA                jmp         main+21h (00401031)
9:
10:       return 0;
00401057 33 C0                xor         eax,eax
11:   }

我们可以看到int data[4];没有生成机器码，说明cpu到这里不会干任何事情。从上面的输出结果可以得出，定义一个数组，会给这个数组分配内存空间，如果没有初始化，数组的内容是相应分配空间的内容，这里我们称之为垃圾值

  • jge：大于等于转移

2、部分初始化

#include "stdio.h"
int main(void)
{
	int data[4]={1,2};
	for (int i=0;i<4;i++)
	{
		printf("%d\t",data[i]);
	}
	
	return 0;
}

结果：
在这里插入图片描述
反汇编：

4:        int data[4]={1,2};
00401028 C7 45 F0 01 00 00 00 mov         dword ptr [ebp-10h],1
0040102F C7 45 F4 02 00 00 00 mov         dword ptr [ebp-0Ch],2
00401036 33 C0                xor         eax,eax
00401038 89 45 F8             mov         dword ptr [ebp-8],eax
0040103B 89 45 FC             mov         dword ptr [ebp-4],eax
5:        for (int i=0;i<4;i++)
0040103E C7 45 EC 00 00 00 00 mov         dword ptr [ebp-14h],0
00401045 EB 09                jmp         main+40h (00401050)
00401047 8B 4D EC             mov         ecx,dword ptr [ebp-14h]
0040104A 83 C1 01             add         ecx,1
0040104D 89 4D EC             mov         dword ptr [ebp-14h],ecx
00401050 83 7D EC 04          cmp         dword ptr [ebp-14h],4
00401054 7D 17                jge         main+5Dh (0040106d)
6:        {
7:            printf("%d\t",data[i]);
00401056 8B 55 EC             mov         edx,dword ptr [ebp-14h]
00401059 8B 44 95 F0          mov         eax,dword ptr [ebp+edx*4-10h]
0040105D 50                   push        eax
0040105E 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
00401063 E8 28 00 00 00       call        printf (00401090)
00401068 83 C4 08             add         esp,8
8:        }
0040106B EB DA                jmp         main+37h (00401047)
9:
10:       return 0;
0040106D 33 C0                xor         eax,eax
11:   }

从下面这段代码可以看出，部分初始化，编译器会给数组分配连续的空间，将有值的部分赋值到相应的内存，没有初始化的，复制为0，这就是为什么上面的输出结果为什么后面没有赋值的是0

4:        int data[4]={1,2};
00401028 C7 45 F0 01 00 00 00 mov         dword ptr [ebp-10h],1
0040102F C7 45 F4 02 00 00 00 mov         dword ptr [ebp-0Ch],2
00401036 33 C0                xor         eax,eax
00401038 89 45 F8             mov         dword ptr [ebp-8],eax
0040103B 89 45 FC             mov         dword ptr [ebp-4],eax

3、全部初始化数组

#include "stdio.h"
int main(void)
{
	int data[4]={1,2,3,4};
	for (int i=0;i<4;i++)
	{
		printf("%d\t",data[i]);
	}
	
	return 0;
}

在这里插入图片描述

4:        int data[4]={1,2,3,4};
00401028 C7 45 F0 01 00 00 00 mov         dword ptr [ebp-10h],1
0040102F C7 45 F4 02 00 00 00 mov         dword ptr [ebp-0Ch],2
00401036 C7 45 F8 03 00 00 00 mov         dword ptr [ebp-8],3
0040103D C7 45 FC 04 00 00 00 mov         dword ptr [ebp-4],4
5:        for (int i=0;i<4;i++)
00401044 C7 45 EC 00 00 00 00 mov         dword ptr [ebp-14h],0
0040104B EB 09                jmp         main+46h (00401056)
0040104D 8B 45 EC             mov         eax,dword ptr [ebp-14h]
00401050 83 C0 01             add         eax,1
00401053 89 45 EC             mov         dword ptr [ebp-14h],eax
00401056 83 7D EC 04          cmp         dword ptr [ebp-14h],4
0040105A 7D 17                jge         main+63h (00401073)
6:        {
7:            printf("%d\t",data[i]);
0040105C 8B 4D EC             mov         ecx,dword ptr [ebp-14h]
0040105F 8B 54 8D F0          mov         edx,dword ptr [ebp+ecx*4-10h]
00401063 52                   push        edx
00401064 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
00401069 E8 22 00 00 00       call        printf (00401090)
0040106E 83 C4 08             add         esp,8
8:        }
00401071 EB DA                jmp         main+3Dh (0040104d)
9:
10:       return 0;
00401073 33 C0                xor         eax,eax

可以看出如果一开始全部初始化数组，会立即分配连续空间给数组，每个空间赋值为数组相应位置的值
4、总结
不初始化数组，数组元素存储的是垃圾值；部分初始化数组，剩余的被初始化为0；全部初始化，将值赋值到相应内存空间，而且数组的物理地址连续

0x02多维数组是如何分配空间的

多维数组的初始化情况和一维数组一样，那么多维数组是如何分配空间的呢？我们以二维数组为列：

#include "stdio.h"
int main(void)
{
	int data[2][2]={{1,2},{3,4}};
	
	return 0;
}

反汇编：

4:        int data[2][2]={{1,2},{3,4}};
00401028 C7 45 F0 01 00 00 00 mov         dword ptr [ebp-10h],1
0040102F C7 45 F4 02 00 00 00 mov         dword ptr [ebp-0Ch],2
00401036 C7 45 F8 03 00 00 00 mov         dword ptr [ebp-8],3
0040103D C7 45 FC 04 00 00 00 mov         dword ptr [ebp-4],4
5:
6:        return 0;
00401044 33 C0                xor         eax,eax
7:    }

我们可以看出先将1,2存到连续空间。再将3,4存到接下来的空间（数组的内存空间是连续的），所以这就是为什么上课时老师说把二维数组当成一维数组来理解了，data[0]和data[1]分别为一个一维数组，二维数组按照从左到右，从上到下存储，地址连续

  • int data[2][2]:data是一个两个元素的数组，每个元素内含2个int类型元素的数组
  • data的首地址是data[0]，data[0]是一个内含2个int类型值的数组，所以data[1]也是这样
0x03 指针和数组

1、一维数组
我们知道数组名是数组的首地址，可为什么呢？接下来我们分析

#include "stdio.h"
int main(void)
{
	int data[4]={1,3,7,4};
	int *p;
	p=data;
	printf("%d\n",p[0]);
	printf("%d\n",*p+2);
	printf("%d\n",*(p+2));
	return 0;
}

结果：
在这里插入图片描述
反汇编：

4:        int data[4]={1,3,7,4};
0040D738 C7 45 F0 01 00 00 00 mov         dword ptr [ebp-10h],1
0040D73F C7 45 F4 03 00 00 00 mov         dword ptr [ebp-0Ch],3
0040D746 C7 45 F8 07 00 00 00 mov         dword ptr [ebp-8],7
0040D74D C7 45 FC 04 00 00 00 mov         dword ptr [ebp-4],4
5:        int *p;
6:        p=data;
0040D754 8D 45 F0             lea         eax,[ebp-10h]
0040D757 89 45 EC             mov         dword ptr [ebp-14h],eax
7:        printf("%d\n",p[0]);
0040D75A 8B 4D EC             mov         ecx,dword ptr [ebp-14h]
0040D75D 8B 11                mov         edx,dword ptr [ecx]
0040D75F 52                   push        edx
0040D760 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D765 E8 26 39 FF FF       call        printf (00401090)
0040D76A 83 C4 08             add         esp,8
8:        printf("%d\n",*p+2);
0040D76D 8B 45 EC             mov         eax,dword ptr [ebp-14h]
0040D770 8B 08                mov         ecx,dword ptr [eax]
0040D772 83 C1 02             add         ecx,2
0040D775 51                   push        ecx
0040D776 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D77B E8 10 39 FF FF       call        printf (00401090)
0040D780 83 C4 08             add         esp,8
9:        printf("%d\n",*(p+2));
0040D783 8B 55 EC             mov         edx,dword ptr [ebp-14h]
0040D786 8B 42 08             mov         eax,dword ptr [edx+8]
0040D789 50                   push        eax
0040D78A 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D78F E8 FC 38 FF FF       call        printf (00401090)
0040D794 83 C4 08             add         esp,8
10:       return 0;
0040D797 33 C0                xor         eax,eax

从数组初始化我们看不出来data是数组的首地址吗，但可以从p=data看出

6:        p=data;
0040D754 8D 45 F0             lea         eax,[ebp-10h]
0040D757 89 45 EC             mov         dword ptr [ebp-14h],eax

把 [ebp-10h]偏移地址给eax，eax再赋值给dword ptr [ebp-14h]，ebp-10h是第一个元素1的地址，所以data是数组首地址，我们将data值赋值给p，此时p和data可以看成等同的，p[0]就是data[0]。

  • 指针加1是增加一个存储单元，比如说*(p+2)，p+2就是增加两个存储单元（int是4byte），所以输出*(p+2)是7
  • 输出p+2，此时p是1，加2是3所以会输出3

2、多维数组
以二维数组为例

#include "stdio.h"
int main(void)
{
	int data[3][3]={{1,2,3},{4,5,6},{7,8,9}};
	int (* p)[3];			//指向一个含有3个int类型的数组
	p=data;
	printf("%d\n",p);
	printf("%d\n",*p);
	printf("%d\n",*(p+1));
	printf("%d\n",**p);
	printf("%d\n",p[0]);
	printf("%d\n",*p[0]);
	return 0;
}

在这里插入图片描述
反汇编：

4:        int data[3][3]={{1,2,3},{4,5,6},{7,8,9}};
0040D738 C7 45 DC 01 00 00 00 mov         dword ptr [ebp-24h],1
0040D73F C7 45 E0 02 00 00 00 mov         dword ptr [ebp-20h],2
0040D746 C7 45 E4 03 00 00 00 mov         dword ptr [ebp-1Ch],3
0040D74D C7 45 E8 04 00 00 00 mov         dword ptr [ebp-18h],4
0040D754 C7 45 EC 05 00 00 00 mov         dword ptr [ebp-14h],5
0040D75B C7 45 F0 06 00 00 00 mov         dword ptr [ebp-10h],6
0040D762 C7 45 F4 07 00 00 00 mov         dword ptr [ebp-0Ch],7
0040D769 C7 45 F8 08 00 00 00 mov         dword ptr [ebp-8],8
0040D770 C7 45 FC 09 00 00 00 mov         dword ptr [ebp-4],9
5:        int (* p)[3];
6:        p=data;
0040D777 8D 45 DC             lea         eax,[ebp-24h]
0040D77A 89 45 D8             mov         dword ptr [ebp-28h],eax
7:        printf("%d\n",p);
0040D77D 8B 4D D8             mov         ecx,dword ptr [ebp-28h]
0040D780 51                   push        ecx
0040D781 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D786 E8 05 39 FF FF       call        printf (00401090)
0040D78B 83 C4 08             add         esp,8
8:        printf("%d\n",*p);
0040D78E 8B 55 D8             mov         edx,dword ptr [ebp-28h]
0040D791 52                   push        edx
0040D792 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D797 E8 F4 38 FF FF       call        printf (00401090)
0040D79C 83 C4 08             add         esp,8
9:        printf("%d\n",*(p+1));
0040D79F 8B 45 D8             mov         eax,dword ptr [ebp-28h]
0040D7A2 83 C0 0C             add         eax,0Ch
0040D7A5 50                   push        eax
0040D7A6 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D7AB E8 E0 38 FF FF       call        printf (00401090)
0040D7B0 83 C4 08             add         esp,8
10:       printf("%d\n",**p);
0040D7B3 8B 4D D8             mov         ecx,dword ptr [ebp-28h]
0040D7B6 8B 11                mov         edx,dword ptr [ecx]
0040D7B8 52                   push        edx
0040D7B9 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D7BE E8 CD 38 FF FF       call        printf (00401090)
0040D7C3 83 C4 08             add         esp,8
11:       printf("%d\n",p[0]);
0040D7C6 8B 45 D8             mov         eax,dword ptr [ebp-28h]
0040D7C9 50                   push        eax
0040D7CA 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D7CF E8 BC 38 FF FF       call        printf (00401090)
0040D7D4 83 C4 08             add         esp,8
12:       printf("%d\n",*p[0]);
0040D7D7 8B 4D D8             mov         ecx,dword ptr [ebp-28h]
0040D7DA 8B 11                mov         edx,dword ptr [ecx]
0040D7DC 52                   push        edx
0040D7DD 68 1C 20 42 00       push        offset string "%d\t" (0042201c)
0040D7E2 E8 A9 38 FF FF       call        printf (00401090)
0040D7E7 83 C4 08             add         esp,8
13:       return 0;
0040D7EA 33 C0                xor         eax,eax
  • 从p=data;， printf("%d\n",p[0]);，printf("%d\n",**p);的反汇编看出，数组名和数组名[0]是首元素的地址，printf("%d\n",*p);，数组名像是指向数组名[0]的指针，这就是为什么二维数组的元素可以看成一维数组
  • printf("%d\n",*(p+1));从反汇编里看出，加了0ch,就是加12，并不是加4，二维数组的元素是一维数组，一维数组占3个int类型，所以12，所以*(p+1)指向data[1]
  • 函数里使用二维数组：比如说int sum(int data[][3])，第一个[]表明data是一个指针
p0inter
关注
专栏目录
汇编里的数组
qq_40710190的博客
06-27 3799
汇编里的数组 一维数组 编译器为Visual Studio 2019 一维数组在汇编里看到其实就是简化版的声明n个变量而已，学过java的可以理解为一个语法糖？ int arr[5] = { 0,1,2,3,4 }; __asm{ mov dword ptr [ebp-3Ch],0 mov dword ptr [ebp-38h],1 mov dword ptr [ebp-34h],2 mov dword ptr [ebp-30h],3 mov
C语言——数组知识大汇总
Cawen的技术博客
08-17 720
1、 定义 数组： 相同类型数据项的集合。 下标变量： 后面跟一个方括号内的下标的变量，指示一个数组元素。 数组下标： 在数组名后的方括号内的数值或表达式，用于指示访问哪个数组元素。 数组是由 ”类型名“ ”标识符“ ”维数“ 组成的复合型数据类型。 ”维数“ 表示数组中包含的元素个数，必须大于等于 1 的常量表达式。此表达式只能包含 ”整型字面常量“ ”枚举常量“ ”用常量表达
汇编 —— 数组
0 error(s)
09-22 3612
文章目录基本原则指针运算练习题练习题答案嵌套数组练习题练习题答案参考文献 基本原则 对于数据类型T和整型常数N，声明如下即为数组： T a[N]; 起始位置表示为Xa，这个声明有两个效果： 在内存中分配一个sizeof(T)*N字节的连续的区域 引入标识符a，可以用a来作为指向数组开头的指针，这个指针的值就是Xa 而在x86-64中的内存引用指令可以用来简化数组访问，比如说，E是一个int型的数组，而我们想要计算E[i]，假设E的地址放在寄存器%rdx中，i 放在寄存器%rcx中，那么访问E[i]的汇
c语言数组指针汇编,C语言到汇编-指针与数组1
weixin_31956641的博客
05-19 323
指针是一种保存变量地址的变量。下面代码声明了指针变量p ，它的值是x 的地址：int x = 1;int *p = &x;一元运算符&可用于取一个对象的地址。一元运算符*是间接寻址或间接引用运算符，当它作用于指针时，将访问指针所指向的对象。下面看一个示例代码：/*1.指针的声明与定义*/int z = 3;int *q = &z;main(){int x = 1;int y...
汇编 数据结构--数组
X_FOCUS的专栏
08-01 1517
<br />回顾： 1、抽象的说数组是一系列具有相同类型元素的集合。<br /><br />            2、数组是最常用的复合数据类型（如指向数组的数组），但最终我们都能分解成元始的元素。<br /><br />            3、数据的基地址是数组第一个元素地址，位于申请数组内存的最低端。指数是否为零与效率无关。<br /><br /><br />对于访问一个一维数组中的元素：<br /><br />      元素地址=元素基地址+（（  指数-初始指数（零））*元素字节数）<br
C与汇编语言
热门推荐
菜鸟进阶之路
06-19 1万+
目录 一、汇编指令 二、汇编器和链接器 三、 汇编语法 四、C中嵌入汇编代码 五、GDB反汇编 1、x86_64通用寄存器 2、 调用栈 3、导出汇编代码 4、反汇编调试详解 5、结构体反汇编 一、汇编指令 汇编指令是指特定CPU架构的指令码的助记符，比如Intel x86 32位下ADD指令对应的16进制机器码有04/05/80/81等，被操作对象不同同一个...
汇编-neon内嵌汇编实现数组相加.zip
最新发布
03-09
在本主题“汇编-NEON内嵌汇编实现数组相加”中，我们将深入探讨如何利用NEON指令集在汇编程序中高效地执行数组元素的加法运算。 NEON技术提供了高级SIMD（单指令多数据）功能，这使得在同一时钟周期内可以处理多个...
C语言课程设计---模拟器和汇编程序的设计.doc
06-02
《C语言课程设计---模拟器和汇编程序的设计》 在C语言课程设计中，模拟器和汇编程序的设计是一项重要的实践任务。该任务旨在帮助学生深入理解计算机系统的底层运作，掌握汇编语言编程和模拟器构建的基本原理。以下...
C语言-参数-返回值-局部变量-数组
qq_20254219的博客
04-15 677
C语言-参数-返回值-局部变量-数组： ​ 返回值 char Funtion(){ //10000行代码 return 10; } //c语言角度：这里定义的函数类型是char（字符型），表示我将返回的的数据是一个字符型数据 //汇编语言角度：我创建了个函数，函数的返回值是一个字节 int main(){ char i = Funtion(); return 0; } //因为我们设置的是返回一个字符型返回值，所以对应的用一个字符型变量去接收 对应的反汇编： call Fu
C语言中的数组和指针汇编代码分析实例
09-03
本文将通过一个简单的C语言程序实例，分析其对应的汇编代码，帮助理解数组和指针在内存中的工作原理。 首先，数组在C语言中本质上是连续的内存空间，用于存储相同类型的数据。在给定的代码示例中，定义了两个字符...
汇编 数组分类
06-28
用汇编语言编写 实现数组中元素的分类。需在代码中设置数据内容
汇编代码 实现数组排序
01-23
用32位汇编语言将一串整型数组排序后输出，其结果显示在屏幕上
8个简单的汇编程序，数组排序、计算最大数，字符串比较，打印图形
07-20
1、计算S=1+2+3+4+……+N直到和大于500为止 2、从键盘输入学生成绩（A、B、C、D），自动汇总并显示各类分数的人数 3、动态输入20个二位无符号数，找出其中最大数并显示 4、设数据区有两个字符串，串1的长度为5，串2的长度为10。编程：若串2的最后5个字符和串1相同，则置FLAG单元为“Y”，否则置为“N” 5、编写打印图形程序 6、用子程序结构编写程序：从键盘入一个二位十进制数的月份（01~12），然后显示相应的英文缩写名 7、数组排序 8、求三个数中最大的数
c语言复习题汇编-复习宝典
11-17
【C语言复习题汇编-复习宝典】 在学习C语言的过程中，理解并掌握基本概念、数据类型、运算符、流程控制以及变量的使用是非常重要的。以下是对标题和描述中涉及的一些关键知识点的详细说明： 1. **常量**： - ...
c语言的汇编表示 数组，指针和字符串
sanqiuai的博客
04-17 621
c语言的汇编表示 数组，指针和字符串 1. void func(int a[]) { } int main () { int a[10]; func(a[1]); //报错 原因：a[1]被当作是一个int类型 ，并不奇怪 return 0; } int main () { int a[10]; func(a[1]); //这样就没有问题 return 0; } void func(int a) { } 2. void func(int a[11]) { //居然可以在形参中定义带有大
汇编学习--数组
gclome的博客
03-09 9681
数组是相同数据类型的元素的集合，它们的内存中按顺序连续存放在一起。在汇编状态下访问数组一般是通过基址加变址寻址实现的。 0x01 先找一个数组访问的C语言代码 #include<stdio.h> int main() { static int a[3]={0x11,0x22,0x33}; int i...
汇编与C（一）
qq_41475825的博客
03-26 691
初窥汇编（使用工具Devc++） Devc++添加调试信号。 工具——>编译选项，再编译器的上上方空白地方添加-g3 先来一个简单的C程序 #include<stdio.h> int g(int x){ return x; } int f(int x){ return x+7; } int main(){ f(1); } 首先我们先了解一下简单的几个汇编指令 push...
逆向知识十三讲,汇编中数组的表现形式,以及还原数组
weixin_30345577的博客
11-29 178
　　　　　　　　　　　　逆向知识十三讲,汇编中数组的表现形式,以及还原数组 讲解数组之前,要了解数组的特性 1.数据具有连续性 2.数据类型相同 比如: 　　int Ary[3] = {0,1,2}; 我们可以看出,上面定义的数组,数据是连续的,其中每个数据类型大小都是int类型(类型也是一样的) 汇编中识别数组: 　　　　1.地址连续 　　　　2.带有比例因子寻址 (...
汇编入门第一篇，小白也能看懂
程序员cxuan的个人主页
10-13 2688
cxuan自己的 Github 非常硬核，求各位大佬 star： https://github.com/crisxuan/bestJavaer 汇编代码是计算机的一种低级表示，它是一种低级语言，可以从字面角度去理解它，包括处理数据、管理内存、读写存储设备上的数据，以及利用网络通信等。编译器生成机器码经过了一系列的转换，这些转换遵循编程语言、目标机器的指令集 和操作系统。 指令集 指令集就是指挥计算机工作的指令，因为程序就是按照一定执行顺序排列的指令。因为计算机的执行控制权由 CPU 操作，所以指令集就是.
C语言程序设计-结构体数组与函数解析
"这篇资源是关于C程序设计语言的课件，主要讲解了结构体数组的概念、C语言的发展特点、简单的C程序示例以及上机操作步骤。" 1. 结构体数组 结构体数组是C语言中一种复合数据类型，允许你将多个不同类型的数据组合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值