Linux基础IO

最新推荐文章于 2024-05-07 22:15:44 发布
原创 最新推荐文章于 2024-05-07 22:15:44 发布 · 446 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #c++ #运维

基础IO

🏞️1. 系统文件I/O

📖1.1 接口介绍

操作文件，除了语言级别的接口，我们还可以采用系统接口来进行文件访问.

open()接口介绍：

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

pathname：要打开或者创建的目标文件

flags：打开文件时，可以传入多个参数选项，用下面的一个或者多个常量进行"或"运算，构成flags.

选项：

O_RDONLY：只读打开
O_WRONLY：只写打开
O_RDWR：读、写打开，这三个常量，必须指定一个且只能指定一个

O_CREAT：若文件不存在，则创建它，需要指明mode选项，来指明新文件的访问权限

O_APPEND：追加写

image-20221119000130029

返回值：

成功：新打开的文件描述符

失败：-1

介绍了这个接口之后，让我们先来简单使用一下它：

int fd = open("test.txt", O_CREAT | O_WRONLY | O_TRUNC);

函数open()接受一些不同的标志. 在本例中，程序创建文件（O_CREAT），只能写入该文件，因为以（O_WRONLY）这种方式打开，并且如果该文件已经存在，则首先将其截断为0字节大小，删除所有现有内容（O_TRUNC）.

write()系统调用：

ssize_t write(int fd, const void *buf, size_t count);

int main()
{
    int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC);

    ssize_t s = write(fd, "aaa", 3);

    close(fd);

    return 0;
}

read()的第一个参数是文件描述符，从而告诉文件系统读取哪个文件，一个进程当然可以同时打开多个文件，因此文件描述符fd使操作系统能够知道某个特定的读取引用了哪个文件.

第二个参数指向一个用于放置read()结果的缓冲区.

第三个参数是缓冲区的大小.

📖1.2 creat系统调用

补充：creat()系统调用

创建文件的旧方法是调用creat()，如下所示：

int fd = creat("foo");

你可以认为creat()是open()加上以下标志：O_CREAT | O_WRONLY | O_TRUNC，因为open()可以创建一个文件，所以creat()的用法有些失宠（实际上，它可能就是实现对open()的一个库调用），然而，它确实在UNIX知识中占有一席之地.

📖1.3 理解fd文件描述符

open()的一个重要方面是它的返回值：文件描述符.

文件描述符只是一个整数，是每个进程私有的，在Linux系统中用于访问文件，因此，一旦文件被打开，你就可以使用文件描述符来读取或写入文件，假如你有权这样做.

那么，我们所，open()系统调用的返回值是文件描述符，不妨我们将它打印出来看看：

image-20221119011839501

观察结果为：3

接下来，不妨我们多创建几个文件看看：

int main()
{
    int fd1 = open("test1.txt", O_WRONLY | O_CREAT | O_TRUNC);
    int fd2 = open("test2.txt", O_WRONLY | O_CREAT | O_TRUNC);
    int fd3 = open("test3.txt", O_WRONLY | O_CREAT | O_TRUNC);
    int fd4 = open("test4.txt", O_WRONLY | O_CREAT | O_TRUNC);
    int fd5 = open("test5.txt", O_WRONLY | O_CREAT | O_TRUNC);

    printf("fa1: %d\n", fd1);
    printf("fa2: %d\n", fd1);
    printf("fa3: %d\n", fd1);
    printf("fa4: %d\n", fd1);
    printf("fa5: %d\n", fd1);


    close(fd1);
    close(fd2);
    close(fd3);
    close(fd4);
    close(fd5);

    return 0;
}

image-20221119012243839

image-20221119013219987

image-20221119014518131

image-20221119015434904

文件描述符的分配规则：在files_struct数组中，找到当前没有被使用的一个最小的下标，作为新的文件描述符.

📖1.4 不按顺序的读取和写入

到目前为止，我们已经讨论过了如何读取和写入文件，但所有访问都是顺序的，也就是说，我们从头到尾读取一个文件，或者从头到尾写一个文件，但是，有时能够读取或写入文件中的特定偏移量是有用的，例如：如果在文本文件上构建了索引并利用它来查找单词，最终可能会从文件中的某些随机偏移量中读取数据，为此，我们将使用lseek()系统调用，下面是函数原型：

off_t lseek(int fd, off_t offset, int whence);

If whence is SEEK_SET, the offset is set to offset bytes.
If whence is SEEK_CUR, the offset is set to its current location plus offset bytes.
If whence is SEEK_END, the offset is set to the size of the file plus offset bytes.

📖1.5 文件重命名

有了一个文件后，有时需要给一个文件一个不同的名字，在命令行键入时，这是通过mv命令完成的，在下面的例子中，文件foo被重命名为bar.

prompt> mv foo bar

利用strace，我们可以看到mv使用了系统调用rename(char* old, char* new)，它只需要两个参数：文件的原来名称和新名称.

rename()调用提供了一个有用的保证：它通常是一个原子调用，无论系统是否崩溃，如果系统在重命名期间崩溃，文件将被命名为旧名称或新名称，不会出现奇怪的中间状态.

int fd = open("foo.txt.tmp", O_WRONLY|O_CREAT|O_TRUNC);
write(fd, buffer, size); // write out new version of file
fsync(fd);
close(fd);
rename("foo.txt.tmp", "foo.txt");

这个例子中，编辑器做的事很简单：将文件的新版本写入临时名称（foot.txt.tmp），使用 fsync()将其强制写入磁盘. 然后，当应用程序确定新文件的元数据和内容在磁盘上，就将临时文件重命名为原有文件的名称. 最后一步自动将新文件交换到位，同时删除旧版本的文件，从而实现原子文件更新.

🌁2. 理解Linux下一切皆文件

在文件描述符中，0、1、2分别对应stdin, stdout, stderr，可是stdin是键盘，stdout是显示器，这也用文件来标识吗？

所以，我们应该如何用文件来标识硬件呢？又如何理解Linux下一切皆文件？

image-20221207223126573

所以，当我们要向硬盘中写入数据时，操作系统的内存文件系统为硬盘创建一个struct file结构，并将struct file结构体中的读写方法函数指针指向对应硬盘的驱动读写方法，当我们想要写入数据时，用struct file中的读写方法便可以完成我们的操作，也实现了以统一的方式看待所有的设备，即Linux下一切皆文件.

🌠3. 理解重定向

📖3.1 重定向原理

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>

int main()
{
    //关闭了stdout
    close(1);
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    if(fd < 0)
    {
        perror("open");
        return 0;
    }

    fprintf(stdout, "打开文件成功, fd: %d\n", fd);

    fflush(stdout);
    close(fd);

    return 0;
}

在这段代码中，进程将自己的stdout关闭，然后打开一个文件，文件描述符的分配规则：遍历文件描述符表，将第一个未分配的下标分配给当前打开的文件，也就是说，fd为1，当我们向stdout中写入数据时，即对应fd为1的文件，本应该写到显示器上的内容就写入到了log.txt中，这不就是重定向吗？

重定向原理：

image-20221207224444432

📖3.2 dup2系统调用

#include <unistd.h>

int dup2(int oldfd, int newfd);

dup2系统调用的作用是将本应该写入newfd中的内容写到oldfd中.

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>

int main()
{
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    if(fd < 0)
    {
        perror("open");
        return 0;
    }

    //将本该写入到文件描述符1中的内容写入到fd中
    dup2(fd, 1);
	
    fprintf(stdout, "打开文件成功, fd: %d\n", fd);

    fflush(stdout);
    close(fd);

    return 0;
}

🌿4. 理解缓冲区

📖4.1 什么是缓冲区

缓冲区的本质就是一段内存.

📖4.2 为什么要有缓冲区？

  1. 解放使用缓冲区的进程时间，可以只将写入放在缓冲区中，就可以做其他任务
  2. 缓冲区的存在可以集中处理数据刷新，减少IO次数，从而达到提高整机效率的目的.

📖4.3 缓冲区存在哪里？

对于我们在进行文件操作时，缓冲区其实是封装在文件FILE结构体中的，可以通过设置刷新策略，来决定什么时候将缓冲区的数据刷新，即什么时候调用write()系统调用.

刷新的本质：把缓冲区的数据write到OS内部，清空缓冲区.

缓冲区存在FILE内部，在C语言中，我们每次打开一个文件，都有一个对应的FILE* 返回，那么也就意味着，每一个文件都有一个fd和属于它自己的语言级别缓冲区.

接下来，我们可以自己试着封装一个FILE来模拟一下这个缓冲区的实现：

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<assert.h>

#define NUM 1024

#define NONE_FLUSH 0x0
#define LINE_FLUSH 0x1
#define FULL_FLUSH 0x2

typedef struct _MyFILE
{
    int _fileno;
    char _buffer[NUM];
    int _end;
    int _flags;  //fflush method
}MyFILE;

MyFILE* my_fopen(const char* filename, const char* method)
{
    assert(filename);
    assert(method);

    int flags = O_RDONLY;

    if(strcmp(method, "r") == 0)
    {}
    else if(strcmp(method, "r+"))
    {}
    else if(strcmp(method, "w") == 0)
    {
        flags = O_WRONLY | O_CREAT | O_TRUNC;
    }
    else if(strcmp(method, "w+") == 0)
    {}
    else if(strcmp(method, "a") == 0)
    {
        flags = O_WRONLY | O_CREAT | O_APPEND;
    }
    else if(strcmp(method, "a+") == 0)
    {}

    int fileno = open(filename, flags, 0666);
    if(fileno < 0)
    {
        return NULL;
    }

    MyFILE* fp = (MyFILE*)malloc(sizeof(MyFILE));
    if(fp == NULL)
        return fp;
    
    memset(fp, 0, sizeof(MyFILE));
    fp->_fileno = fileno;
    fp->_flags |= LINE_FLUSH;
    fp->_end = 0;

    return fp;
}

void my_fflush(MyFILE* fp)
{
    assert(fp);

    if(fp->_end > 0)
    {
        write(fp->_fileno, fp->_buffer, fp->_end);
        fp->_end > 0;
        syncfs(fp->_fileno);
    }
}

void my_fwrite(MyFILE* fp, const char* start, int len)
{
    assert(fp);
    assert(start);
    assert(len > 0);

    //将数据写入缓冲区
    strncpy(fp->_buffer + fp->_end, start, len);
    fp->_end += len;

    if(fp->_flags & NONE_FLUSH)
    {}
    else if(fp->_flags & LINE_FLUSH)
    {
        if(fp->_end > 0 && fp->_buffer[fp->_end - 1] == '\n')
        {
            //写到内核中
            write(fp->_fileno, fp->_buffer, fp->_end);
            fp->_end = 0;
            syncfs(fp->_fileno);
        }
    }
    else if(fp->_flags & FULL_FLUSH)
    {}
}

void my_fclose(MyFILE* fp)
{
    my_fflush(fp);
    close(fp->_fileno);
    free(fp);
}

🍁5. 硬链接和软链接

在谈论软硬链接之前，我们先使用一下它：

建立软链接：

image-20221208135300869

建立硬链接：

image-20221208135508917

image-20221208135628918

那么，我们明显观察到了软链接和硬链接的一个不同：

软链接的inode编号与它所链接的文件不同，而硬链接的inode编号与它所链接的文件是相同的.

其实，软链接是一个独立的文件，而硬链接就是单纯在Linux指定的目录下，给指定的文件新增文件名和inode编号的映射关系.

怎么使用软硬链接呢？

首先我们来看软链接的使用：

现在，我们在距离当前目录较远的目录下建立一个可执行程序：

image-20221208140510707

如果不使用软链接，我们在执行可执行程序的时候就需要带上指定路径，但有了软链接，我们就可以在当前目录下为它建立一个软链接，从而直接执行它：

image-20221208140719874

硬链接的使用：

在使用硬链接之前，首先我们来认识一个叫硬链接数的概念：

image-20221208140942036

硬链接数本质就是该文件inode属性中的一个计数器，标识有几个文件名和我的inode建立了映射关系.

一个普通文件的默认硬链接数就是1，因为它自己的文件名就和它的inode建立了映射.

创建一个空的目录，它的默认链接数是2：

image-20221208141337659

因为除了它自己的文件名和自己的inode建立了链接，在它的目录下，还有一个.与它的inode也建立了映射.

Linux 基础IO（Input与output）学习
weixin_59215611的博客
04-05 917
基础IO（Input与output）学习
linux串口属性O_CTTY O_NDELAY
咔嚓咔嚓咔嚓
12-29 2792
O_NOCTTY：告诉Unix这个程序不想成为“控制终端”控制的程序，不说明这个标志的话，任何输入都会影响你的程序。 O_NDELAY：告诉Unix这个程序不关心DCD信号线状态，即其他端口是否运行，不说明这个标志的话，该程序就会在DCD信号线为低电平时停止。
使用串口时O_NOCTTY | O_NDELAY参数作用
weixin_45515270的博客
08-01 2万+
Linux打开串口和打开文件一样使用open函数 例如： fd1 = open( "...", O_RDWR | O_NOCTTY | O_NDELAY); 参数： “…” ： 文件路径 O_RDWR ： 可读可写 O_NOCTTY ：该参数不会使打开的文件成为该进程的控制终端。如果没有指定这个标志，那么任何一个 输入都将会影响用户的进程。 O_NDELAY ：这个程序不关心DCD信号线所处的状态,端口的另一端是否激活或者停止。如果用户不指定了这个标志，则
Linux文件io编程
weixin_51115390的博客
05-10 134
文件I/O
Linux下的串口编程
蓝精灵的专栏
06-21 605
一．Linux下的串口编程又那几部分组成     1.    打开串口 2.    串口初始化 3.    读串口或写串口 4.    关闭串口 二．串口的打开 既然串口在linux中被看作了文件，那么在对文件进行操作前先要对其进行打开操作。 1.在Linxu中，串口设备是通过串口终端设备文件来访问的，即通过访问/dev/ttyS0,/
【Linux 基础 IO】文件系统，对系统调用函数的讲解
Hou_lang_LJ的博客
05-07 808
①🐧 文件的初步介绍； ②🐧 系统调用函数的使用；
【Linux编程】深入解析Linux标准IO函数：核心概念、常用函数及实际应用Linux标准IO函数
最新发布
04-06
适用人群：有一定C语言基础，从事Linux系统编程或对文件操作感兴趣的开发者。 使用场景及目标：①理解Linux标准IO函数的基本概念、核心原理及其实现机制；②掌握文件打开、关闭、读写、定位等常用操作；③熟悉缓冲区...
Linux-IO性能优化基础工具和实践
03-05
Linux-IO性能优化基础工具和实践： 基础篇-Linux IO stack overview 基础篇-read syscall IO stack 工具篇-iostat数据可靠吗 工具篇-blktrace原理和应用 工具篇-debugfs应用 Cache server机械盘IO性能瓶颈分析 实践...
Linux编程下open()函数的用法
热门推荐
魏波
01-11 4万+
Linux编程下open()函数的用法 open（打开文件） 相关函数： read，write，fcntl，close，link，stat，umask，unlink，fopen 表头文件 ： #include #include #include 定义函数： int open( const char * pathname, int flags); int ope
O_NONBLOCK与O_NDELAY有何不同
qilu0882的专栏
11-10 1万+
O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非阻塞模式(non-blocking)，在读取不到数据或是写入缓冲区已满会马上return，而不会阻塞等待。 它们的差别在于：在读操作时，如果读不到数据，O_NDELAY会使I/O函数马上返回0，但这又衍生出一个问题，因为读取到文件末尾(EOF)时返回的也是0，这样无法区分是哪种情况。因此，O_NONBLOCK就产生出来，它在
linux下 O_NONBLOCK与O_NDELAY的区别
猪哥的专栏
05-26 4337
在上一篇文章《linux下“阻塞”与“非阻塞”的定义及区别》中，我们分析了阻塞和非阻塞两种模式，与“非阻塞模式”相关的有两个 标志，就是 O_NONBLOCK与O_NDELAY，这两种参数的结果都是使I/O操作设置为“非阻塞模式”，也就是non-blocking，当进行read/write操作时，不管结果如何，都会马上返回，而不会阻塞。 他们的区别是：在read时，如果读不到数据,O_NDELAY会返回0，由于正常读取到文件末尾时，也会返回0，这样就无法区分是否是遗产隔离，所以就引入了O_NONBLOCK,
o在linux是什么权限,Linux权限管理基本知识大全
weixin_42112685的博客
04-30 1229
Linux权限管理基本知识大全Linux系统有什么基本权限，权限管理命令是什么?下面跟yjbys小编一起来看看吧!一、基本权限linux权限机制采用UGO模式。其中 u(user)表示所属用户、g(group)表示所属组、o(other)表示除了所属用户、所属组之外的情况。u、g、o 都有读(read)、写(write)、执行(excute) 三个权限，所以UGO模式是三类九种基本权限。用命令 l...
o在linux是什么权限,Linux中的权限
weixin_35020039的博客
04-30 961
1.文件与目录权限1)UID与GIDØUIDUID是一个数值，是Linux系统中唯一的用户标识，用于区别不同的用户。在系统内部管理进程和文件保护时使用UID字段。在Linux系统中，注册名和UID都可以用于标识用户，只不过对于系统来说UID更为重要；而对于用户来说注册名使用起来更方便。在某些特定目的下，系统中可以存在多个拥有不同注册名、但UID相同的用户，事实上，这些使用不同注册名的用户实际上是同...
linux中.o,.a,.o,.so文件的意义和编程实现
IT老兵
12-11 1万+
    转自 烟雨楼 http://hi.baidu.com/yanyuloulinux下文件的类型是不依赖于其后缀名的，但一般来讲： .o,是目标文件,相当于windows中的.obj文件 .so 为共享库,是shared object,用于动态连接的,和dll差不多 .a为静态库,是好多个.o合在一起,用于静态连接 .la为libtool自动生成的一些共享库，vi编辑查看，主要记录了一些配置信
Linux常见命令
O_MMMM_O的博客
08-20 1622
Linux常见命令 Linux简介及Ubuntu安装 常见指令 系统管理命令 打包压缩相关命令 关机/重启机器 Linux管道 Linux软件包管理 vim使用 用户及用户组管理 文件权限管理 Linux简介及Ubuntu安装Linux，免费开源，多用户多任务系统。基于Linux有多个版本的衍生。RedHat、Ubuntu、Debianaa 安装VMware或VirtualBox虚拟机。具体安装步
基础ioLinux
03-24
<think>好的，我现在需要帮助用户了解Linux下的基础IO操作教程。根据用户提供的引用内容，我需要整合这些信息，并按照系统级指令的要求来组织回答。首先，用户提到引用了四个不同的来源，其中引用了Linux基础IO、进程控制、文件操作以及标准IO和系统调用IO的区别等内容。 首先，我需要确保回答结构清晰，分步骤解释Linux的基础IO操作。根据引用[2]，Linux中一切皆文件，包括标准输入输出和硬件外设，所以应该从文件描述符和文件操作的系统调用开始。然后，引用[3]和[4]提到了标准IO和系统调用IO的区别，需要详细说明两者的不同以及使用场景。用户可能对如何打开、读写文件，以及文件描述符的管理感兴趣。 接下来，按照系统级指令，所有行内数学表达式需要用$...$格式，但在这个问题中可能数学公式较少，更多是代码和命令。独立公式如果需要的话用$$...$$，不过可能这里不需要。需要检查LaTeX语法是否正确，使用中文回答，并生成相关问题。 然后，根据用户提供的引用内容，需要将相关知识组织成教程。例如，文件描述符的概念、系统调用如open、read、write、close的使用，标准库函数如fopen、fread、fwrite，以及两者的区别和选择。此外，可能需要提到文件权限、缓冲机制等。 还要注意引用标识的正确添加，例如在提到一切皆文件时引用[^2]，在标准IO和系统调用IO的区别时引用[^3]，在提到fwrite参数时引用[^4]。同时，用户的问题是关于基础IO操作的教程，因此需要涵盖基本操作步骤、常用函数和示例代码。 最后，生成相关问题，可能需要包括系统调用与标准库函数的比较、文件描述符的管理、缓冲机制的影响等。 现在需要将这些内容整合成一个结构清晰的中文回答，符合用户指定的格式，包括代码块和引用标注，最后生成相关问题列表。</think>### Linux 基础 IO 操作教程 #### 一、文件描述符与“一切皆文件”原理 在 Linux 中，所有硬件设备（如键盘、显示器）和软件资源（如普通文件）均被视为**文件对象**。操作系统通过统一的接口（读方法、写方法）驱动这些对象，并使用文件描述符（`fd`）进行管理。例如，标准输入（键盘）对应 `fd=0`，标准输出（显示器）对应 `fd=1`，标准错误对应 `fd=2`[^2]。 #### 二、系统调用 IO 操作 1. **打开文件** 使用 `open` 函数： ```c #include <fcntl.h> int fd = open("test.txt", O_RDWR | O_CREAT, 0644); // 权限模式 0644 ``` - 参数：文件名、标志位（如 `O_RDONLY` 只读）、权限 - 返回值：成功返回文件描述符，失败返回 -1 2. **读写文件** - `read` 函数： ```c ssize_t num = read(fd, buffer, sizeof(buffer)); // 返回实际读取字节数 ``` - `write` 函数： ```c ssize_t num = write(fd, "Hello", 5); // 返回实际写入字节数 ``` 3. **关闭文件** ```c close(fd); // 释放文件描述符 ``` #### 三、标准 IO 库函数 标准 IO（如 `fopen`）通过**用户空间缓冲区**提升效率，适合高频小数据操作[^3]。 1. **打开文件** ```c FILE* fp = fopen("test.txt", "r+"); // 模式包括 "r"（读）、"w"（写） ``` 2. **读写操作** - `fread`： ```c size_t count = fread(buffer, sizeof(char), 100, fp); // 读取100个char类型数据 ``` - `fwrite`： ```c fwrite("Data", 1, 4, fp); // 参数：数据指针、块大小、块数量、文件指针 ``` 3. **关闭文件** ```c fclose(fp); // 刷新缓冲区并关闭 ``` #### 四、系统调用 IO 与标准 IO 的选择 | **场景** | **推荐方法** | **原因** | |------------------------|-------------------|-----------------------------| | 高频小数据读写 | 标准 IO（如 `fprintf`） | 缓冲区减少系统调用次数 | | 直接访问硬件驱动程序 | 系统调用 IO | 绕过缓冲区，直接操作底层 | #### 五、关键概念解析 - **文件描述符表**：每个进程独立维护，通过 `fd` 索引内核中的文件对象。 - **缓冲机制**：标准 IO 的三种缓冲模式（全缓冲、行缓冲、无缓冲）通过 `setvbuf` 设置。 ```c // 示例：复制文件内容（系统调用 IO） #include <unistd.h> #include <fcntl.h> int main() { int src_fd = open("src.txt", O_RDONLY); int dest_fd = open("dest.txt", O_WRONLY | O_CREAT, 0644); char buf[1024]; ssize_t num; while ((num = read(src_fd, buf, sizeof(buf))) > 0) { write(dest_fd, buf, num); } close(src_fd); close(dest_fd); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沉默.@

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

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

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

打赏作者

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

抵扣说明：

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

余额充值