c++IO流

最新推荐文章于 2022-10-15 12:26:55 发布
最新推荐文章于 2022-10-15 12:26:55 发布
阅读量888 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zstuyyyyccccbbbb/article/details/121376968
版权

IO流

  • C语言的输入与输出
  • 流是什么
  • CppIO流
  • stringstream的介绍

1.C语言的输入与输出

C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。其他还有文件读写的接口，网络中API。

scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。

printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度输出控制。

C语言借助了相应的缓冲区来进行输入与输出。

IO：输入输出

设备：磁盘，网卡，显示器

image-20211116140823631

IO接口函数屏蔽底层细节。

对输入输出缓冲区的理解：

1.可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差 异，可以很容易写出可移植的程序。

2.可以使用这部分的内容实现“行”读取的行为，对于计算机而言是没有“行”这个概念，有了这部分，就可以 定义“行”的概念，然后解析缓冲区的内容，返回一个“行”。

2.流是什么

“流”即是流动的意思，是物质从一处向另一处流动的过程，是对一种有序连续且具有方向性的数据（ 其单位 可以是bit,byte,packet ）的抽象描述。 C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存） 输入和从内存向外部输出设备（显示器）输出的过程。这种输入输出的过程被形象的比喻为“流”。

比如

cin>>s.name>>s.age;//数据从设备（终端）流向对象（内存）
cout<<s.name<<s.age<<endl;//数据对象（内存）流向终端

3.c++的IO流

C++系统实现了一个庞大的类库，其中ios为基类，其他类都是直接或间接派生自ios。

但c++标准库并没提供网络的接口。

cin和cout是istream的全局对象。

本意是cout进行正常的输出，cerr进行错误的输出，clog是进行日志的输出。不过后两个基本没人用。

fstream是以流的方式进行读写文件。

sstream是进行字符串的序列化和反序列化，用于网络。

image-20211116141605371

3.1c++标准IO流

C++标准库提供了4个全局流对象cin、cout、cerr、clog。

使用cout进行标准输出，即数据从内存流向控制台(显示器)。

使用cin进行标准输入即数据通过键盘输入到程序中，

同时C++标准库还提供了cerr用来进行标准错误的输出，以及clog进行日志的输出，从上图可以看出，cout、cerr、clog是ostream类的三个不同的对象，因此这三个对象现在基本没有区别，只是应用场景不同。

image-20211116143408997

image-20211116143419925

struct P{
    string name="xxx";
    int age=21;
};
int main(void){
    P s;
    cout<<"名字:"<<s.name<<" 年龄:"<<s.age<<endl;
    printf("名字:%s 年龄:%d\n",s.name.c_str(),s.age);
   	return 0;
}

image-20211116143622773

这样的输入看起来可以，但是实际上是不行的。

struct P{
    string name="xxx";
    int age=21;
};
int main(void){
    P s;
    cin>>s.name>>s.age;
    scanf("%s%d",s.name.c_str(),&s.age);
   	return 0;
}

cin的时候不论输入的时候多长，我们自己当时实现的时候是push_back。

    istream& operator>>(istream& in,const string&s){
        s.clear();//库的string虽然初始化好了重新输入的时候是新的内容。
        while(1){
            char ch;
            //in>>ch;///系统实现的cin>>ch,输入'\n'接收不到
            in.get(ch);
            if(ch=='\n'){
                break;
            }
            s+=ch;
        }
        return in;
    }

             //s1+='a';
        	string& operator+=(char ch){
                this->push_back(ch);
                return *this;
            }

image-20211116145529112

string在第一次输入的时候是动态的，而后面scanf直接输入是在string的指针后面追加，并没有扩容，所以会出事。

再比如：

struct P{
    string name="xxx";
    int age=21;
};
int main(void){
    P s;
    cin>>s.name>>s.age;
    cout<<"名字:"<<s.name<<" 年龄:"<<s.age<<endl;
    scanf("%s%d",s.name.c_str(),&s.age);
    printf("名字:%s 年龄:%d\n",s.name.c_str(),s.age);
    cout<<"名字:"<<s.name<<" 年龄:"<<s.age<<endl;
   	return 0;
}

image-20211116150008371

回想模拟string类的时候，string的cout我们是按照size来输出的，而自带的printf是按照’\0’输出的。直接从scanf输入并没有改变size。因此如果非要用scanf给string，那么提前对string使用resize把空间开好。

建议：

  1. C++尽量去用cin和cout，能用它就用它
  2. 用cout和cin不方便的地方，再去使用scanf和printf
    1. 比如输出浮点数的小数点位数，cout的代码比printf多很多。

注意：

  1. cin为缓冲流，键盘输入的数据保存在缓冲区中，当要提取时，是从缓冲区中拿。如果一次输入过多， 会留在那儿慢慢用，如果输入错了，必须在回车之前修改，如果回车键按下就无法挽回了。只有把输入缓冲区中的数据取完后，才要求输入新的数据。

  2. 输入的数据类型必须与要提取的数据类型一致，否则出错。出错只是在流的状态字state中对应位置位 （置1），程序继续。

  3. 空格和回车都可以作为数据之间的分格符，所以多个数据可以在一行输入，也可以分行输入。但如果是字符型和字符串，则空格（ASCII码为32）无法用cin输入，字符串中也不能有空格。回车符也无法读入。读取一行要使用getline。

  4. cin和cout可以直接输入和输出内置类型数据，原因：标准库已经将所有内置类型的输入和输出全部重 载image-20211116151719716

  5. 对于自定义类型，如果要支持cin和cout的标准输入输出，需要对<<和>>进行重载。

  6. 对于IO类型的算法，一般都需要循环输入，可以使用ctrl+c就退出了。

    1. while(cin>>a){ //实际调用的是operator>>(cin,str)函数，函数的返回值类型是istream&，返回对象是cin。

    cout<<a<<endl;
}
while(scanf("%d",&a)!=EOF){

}

    2. 后者好理解，scanf函数的返回值，前者难道也有返回值吗?

    3. image-20211116153610111

    4. image-20211116154056929

    5. cin会强转，如果发生了错误（比如说ctrl+c使流停止）则返回空指针（相当于逻辑0），不然就是其他值。那么除了0以外其他仍被认为是true。

    6. 因此我们想要一个自定义类型对象可以去直接做条件逻辑判断，就可以去重载 operator void*（）或者operator bool（）。（看起来确实怪）。跟operator new很像，属于重载中的特例。不像其他的写法一样重载运算符。

      1. 假设我想把对象类型强转成bool，而类型强转（）这个运算符场景不仅仅这里需要，其他地方也有。bool operator（）（）【那就要写成这样】，void* operator（）（）【那就要写成这样】。但是这样编译器就不好进行语法分析了。
      2. 重载了operator（）的类叫仿函数，因为这个类的对象看起来可以像函数一样去使用。因此上面的形式编译器就不好判断是仿函数还是转成条件逻辑判断式了。
      3. 所以记住想要自定义类型对象做条件逻辑判断重载的方式是explict operator bool（） const；可以理解为是类型强转的重载

3.2c++文件IO流

image-20211116162319780

  • ifstream是用来读的。
  • ofstream是用来写的。

其析构的时候会调用close（）；

常用接口：

image-20211116163651191

image-20211116163440091

image-20211116163553880

image-20211116163625877

如标准IO流中提到的，这些流都重载了operator bool() const；都有返回值可以当逻辑判断。

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
void readfile(){
    ifstream ifs("IO流例子.cpp");
    char ch;
    /*
    while( (ch=ifs.get())!=EOF){
        cout<<ch;
    }*/
    /*while(ifs.get(ch)){
        cout<<ch;
    }*/
    while(ifs){
        cout<<(char)ifs.get();
    }
}
int main(void){
    readfile();
   	return 0;
}

image-20211116164816182

void writefile(){
    ofstream ofs("test.txt");
    ofs.put('h');
    ofs.write("hello world",11);
}
int main(void){
    ///readfile();
    writefile();
   	return 0;
}

image-20211116165335691

3.2.1二进制文件读写
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
struct ConfigManager{
    ConfigManager(const string& Configaddress)
    :_Configaddress(Configaddress)
    {}
    ///以二进制形式写出
    ConfigWbin(const Server& server){
        ofstream ofs(_Configaddress);
        ofs.write((char*)&server,sizeof(server));

    }
    ///以二进制形式读入
    ConfigRbin(const Server& server){
        ifstream ifs(_Configaddress);
        ifs.read((char*)&server,sizeof(server));
    }
private:
    string _Configaddress;
};
int main(void){
    ConfigManager CM("IOtest.txt");
    Server s={"192.168.0.1",8336};
    CM.ConfigWbin(s);
    Server p;
    CM.ConfigRbin(p);
    cout<<p.Ip<<" "<<p.port<<endl;
   	return 0;
}

image-20211117105537212

image-20211117105601896

可以发现二进制的好处就是方便，直接全部转化成字符给传出去，不过坏处就是我们看不了二进制文件，只能看到原本是ascii表示的。

3.2.2文本文件读写
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
struct ConfigManager{
public:
    ConfigManager(const string& Configaddress)
    :_Configaddress(Configaddress)
    {}
    ///以二进制形式写出
    ConfigWbin(const Server& server){
        ofstream ofs(_Configaddress);
        ofs.write((char*)&server,sizeof(server));

    }
    ///以二进制形式读入
    ConfigRbin(Server& server){
        ifstream ifs(_Configaddress);
        ifs.read((char*)&server,sizeof(server));
    }
    ///以文本形式写出(全转成字符串)
    ConfigWtxt(const Server& server){
        ofstream ofs(_Configaddress);
        ofs.write(server.Ip.c_str(),server.Ip.length());
        ofs.put('\n');
        string tmp=to_string(server.port);
        ofs.write(tmp.c_str(),tmp.length());
    }
    ///以文本形式读入
    ConfigRtxt(Server& server){
        ifstream ifs(_Configaddress);
        char str[20];
        ifs.getline(str,20);
        server.Ip=(str);
        ifs.getline(str,20);
        string tmp(str);
        server.port=stoi(tmp);
    }
private:
    string _Configaddress;
};
int main(void){
    ConfigManager CM("IOtest.txt");
    Server s={"192.168.0.3",8446};
    CM.ConfigWtxt(s);
    Server p;
    CM.ConfigRtxt(p);
    cout<<p.Ip<<" "<<p.port<<endl;
   	return 0;
}

image-20211117114019420

image-20211117114034917

3.2.3流读写
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
struct ConfigManager{
public:
    ConfigManager(const string& Configaddress)
    :_Configaddress(Configaddress)
    {}
    ///以二进制形式写出
    ConfigWbin(const Server& server){
        ofstream ofs(_Configaddress);
        ofs.write((char*)&server,sizeof(server));

    }
    ///以二进制形式读入
    ConfigRbin(Server& server){
        ifstream ifs(_Configaddress);
        ifs.read((char*)&server,sizeof(server));
    }
    ///以文本形式写出(全转成字符串)
    ConfigWtxt(const Server& server){
        ofstream ofs(_Configaddress);
        ofs.write(server.Ip.c_str(),server.Ip.length());
        ofs.put('\n');
        string tmp=to_string(server.port);
        ofs.write(tmp.c_str(),tmp.length());
    }
    ///以文本形式读入
    ConfigRtxt(Server& server){
        ifstream ifs(_Configaddress);
        char str[20];
        ifs.getline(str,20);
        server.Ip=(str);
        ifs.getline(str,20);
        string tmp(str);
        server.port=stoi(tmp);
    }
    ///以流形式写出
    ConfigCouttxt(const Server& server){
        ofstream ofs(_Configaddress);
        ofs<<server.Ip<<" "<<server.port;
    }
    ///以流形式读入
    ConfigCintxt(Server& server){
        ifstream ifs(_Configaddress);
        ifs>>server.Ip>>server.port;
    }
private:
    string _Configaddress;
};
int main(void){
    ConfigManager CM("IOtest.txt");
    Server s={"192.168.0.5",8446};
    CM.ConfigCouttxt(s);
    Server p;
    CM.ConfigCintxt(p);
    cout<<p.Ip<<" "<<p.port<<endl;
   	return 0;
}

image-20211117114522256

image-20211117114541685

3.3字符串的序列化与反序列化

  1. stringstream实际是在其底层维护了一个string类型的对象用来保存结果。
  2. 多次数据类型转化时，一定要用clear()来清空，才能正确转化，但clear()不会将stringstream底层的 string对象清空。
  3. 可以使用s. str("")方法将底层string对象设置为""空字符串。
  4. 可以使用s.str()将让stringstream返回其底层的string对象。
  5. stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参数类型进 行推演，不需要格式化控制，也不会出现格式化失败的风险，因此使用更方便，更安全。
3.3.1C语言的方式

可以发现C语言的方式需要开一个额外的数组，但是我们并不知道要开多大。所以这种方式实际上存在缺陷。

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
int main(void){
    Server s={"111111111111111111111111111111111111111111192.168.0.1",8843};
    ///序列化(C语言方式)
    char str[256];
    sprintf(str,"%s %d",s.Ip.c_str(),s.port);
    ///反序列化(C语言方式)
    Server p;
    p.Ip.resize(s.Ip.size());
    sscanf(str,"%s%d",p.Ip.c_str(),&p.port);
    printf("%s %d",p.Ip.c_str(),p.port);
   	return 0;
}

image-20211117134646521

3.3.2C++的stringstream
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
int main(void){
    Server s={"111111111111111111111111111111111111111111192.168.0.1",8843};
    ///序列化(C语言方式)
//    char str[256];
//    sprintf(str,"%s %d",s.Ip.c_str(),s.port);
//    ///反序列化(C语言方式)
//    Server p;
//    p.Ip.resize(s.Ip.size());
//    sscanf(str,"%s%d",p.Ip.c_str(),&p.port);
//    printf("%s %d",p.Ip.c_str(),p.port);

    ///C++sstream
    stringstream ssm;
    ssm<<s.Ip<<s.port;
    string buff=ssm.str();

    Server rc;
    ssm>>rc.Ip>>rc.port;
    cout<<rc.Ip<<" "<<rc.port<<endl;
   	return 0;
}

image-20211117135244570

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
int main(void){
    Server s={"111111111111111111111111111111111111111111192.168.0.1",8843};
    ///序列化(C语言方式)
//    char str[256];
//    sprintf(str,"%s %d",s.Ip.c_str(),s.port);
//    ///反序列化(C语言方式)
//    Server p;
//    p.Ip.resize(s.Ip.size());
//    sscanf(str,"%s%d",p.Ip.c_str(),&p.port);
//    printf("%s %d",p.Ip.c_str(),p.port);

    ///C++sstream
//    stringstream ssm;
//    ssm<<s.Ip<<s.port;
//    string buff=ssm.str();
    stringstream  ssm;
    ssm.str("192.168.0.1 8843");
    Server rc;
    ssm>>rc.Ip>>rc.port;
    cout<<rc.Ip<<" "<<rc.port<<endl;


   	return 0;
}

image-20211117135407877

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+1000;
typedef long long LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
struct Server{
    string Ip;
    int port;
};
int main(void){
    Server s={"111111111111111111111111111111111111111111192.168.0.1",8843};
    ///序列化(C语言方式)
//    char str[256];
//    sprintf(str,"%s %d",s.Ip.c_str(),s.port);
//    ///反序列化(C语言方式)
//    Server p;
//    p.Ip.resize(s.Ip.size());
//    sscanf(str,"%s%d",p.Ip.c_str(),&p.port);
//    printf("%s %d",p.Ip.c_str(),p.port);

    ///C++sstream
//    stringstream ssm;
//    ssm<<s.Ip<<s.port;
//    string buff=ssm.str();
//    stringstream  ssm;
//    ssm.str("192.168.0.1 8843");
    stringstream ssm("192.168.0.1 8843");
    Server rc;
    ssm>>rc.Ip>>rc.port;
    cout<<rc.Ip<<" "<<rc.port<<endl;


   	return 0;
}

image-20211117135530097

小菜鸡加油
关注
专栏目录
C++的IO流
h1091068389的博客
05-03 185
C++的IO流流的概念标准IO流注意事项文件读写操作C语言的读写操作C语言的写操作（二进制）C语言的读操作（二进制）C语言的写操作（文本形式）C语言的读操作（文本形式）C++的读写操作文件写操作（二进制）文件写操作（文本形式）文件读操作（二进制）文件读操作（文本形式） 流的概念 在之前的博客中有提到过C语言的IO流的概念。C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。 scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。printf(): 将指定的文字/字符
【C++】一文掌握C++中的IO流
最新发布
叫我龙翔的博客
08-16 1485
本文详细讲解了C++中的IO流体系，讲解了各种接口的使用方法！
浅谈C++ IO流
08-24
"浅谈C++ IO流" C++ IO流是一种抽象概念，它代表了数据的无结构化传递。在计算机科学中，输入输出（IO）是指计算机同任何外部设备之间的数据传递。常见的输入输出设备有文件、键盘、打印机、屏幕等。数据可以按记录...
C++IO流拆分字符串
05-24
本文将深入探讨如何在C++中使用IO流来拆分字符串，并提供不同方法的源码实现。 首先，C++标准库中的`std::getline`函数是进行行级拆分的常用工具，它可以从输入流中读取一行，并将其作为字符串返回。例如，我们可以...
C++ IO流作业
huyaoyuyue的博客
12-07 586
流：若干字节数据从一端到达另一端我们叫做流 流类体系：流对象，和流运算符>> << 输入输出流 ostream类：cout,cerr,clog，istream类 cin #include<iostream> using namespace std; void testostream() { cout << "标准输出" << endl; //可以重定向 cerr << "标准出错" <&lt.
C++程序设计与数据结构基础：第8章 C++ IO流标准库.ppt
06-12
C++程序设计与数据结构基础：第8章 C++ IO流标准库 本章内容主要讲解了C++程序设计中的IO流标准库，涵盖了C++ I/O流概述、控制台与文件的输入与输出、外部存储介质、内存变量写文件（输出）读文件（输入）等方面的...
C++IO流
weixin_44614083的博客
05-14 547
系列文章目录 C++入门 C++类和对象（上） C++类和对象（中） C++类和对象（下） C/C++内存管理 C++string类 C++vector类 C++list类 C++stack和queue C++双端队列 C++模板进阶 文章目录系列文章目录前言一、流（stream）是什么？二、C++的I/O流1.C++标准IO流2.C++文件IO流三、stringstream的介绍 前言 在C语言中，我们用到最频繁的输入输出方式就是scanf和printf scanf:从标准输入流（键盘）读数据并存放在
c++ 的IO流
A_supi的博客
04-24 308
文件流对象 C++根据文件内容的数据格式分为二进制文件和文本文件 文件的操作步骤： 定义一个文件流对象 ifstream ifile(只输入用) ofstream ofile(只输出用) fstream iofile(既输入又输出用) 使用文件流对象的成员函数打开一个磁盘文件，使得文件流对象和磁盘文件之间建立联系 使用提取和插入运算符对文件进行读写操作，或使用成员函数进行读写 关闭文件 ...
c++ IO流
woshihuanqi的专栏
08-30 1043
<br />一、使用流<br /> 1、到底什么是流<br />   cout和cin都是在C++的std命名空间中预定义的流实例。<br />   每个输入流都有一个相关联的源，每个输出流都有一个相关联的目的。<br /> 2、流的源和目的<br />   控制台流、文件流、字符串流，还有比如打印机输出或网络I/O是由操作系统提供的，并没有内置到C++语言中。<br /> 3、流输出<br />   ①、cout流是把数据写到控制台或者标准输出的内置流。<br />   ②、C++流可以正确地解析C风格的
C++ IO流
风间琉璃的博客
10-15 1291
IO流包括：标准IO流，字符串流，文件流。C++流是指信息从外部输入设备向计算机内部输入和从计算机内部向外部输出设备输出的过程。这种输入输出的过程被形象的比喻为“流”。
23IO流
lzjsqn的专栏
06-20 749
IO流IO流 流类库结构 标准IO 1标准输入 2标准输出 文件IO 1文件流及其对象 2文件的基本操作 3对ASCII文件的操作 4对二进制文件的操作 1.流类库结构程序的输入指的是从输入文件将数据传送给程序，程序的输出指的是从程序将数据传送给输出文件。C++输入输出包含以下三个方面的内容： 对系统指定的标准设备的输入和输出。即从键盘输入数据，输出到显示器屏幕。这种输入输出称为标准的输入输出，简称
C++程序设计：C++ IO流标准库详解
C++程序设计与数据结构基础：第8章 C++ IO流标准库 本章内容主要围绕C++ IO流标准库展开，讨论了C++ IO流的概述、控制台与文件的输入与输出、如何把处理过的数据存储起来等问题。 一、C++ IO流概述 C++ IO流是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值