C++——流和输入输出

写在前面

应该知道的一些知识

掩码(mask)

定点计数法

科学计数法  //应该都知道

基本认识 

C++把程序的输入和输出看作一个字节流

流的概念:流是一个抽象、动态的概念,是一连串连续动态的数据集合。 对于输入流而言,数据源就像水箱,流 (stream)就像水管中流动着的水流,程序就是我们最终的用户。 我们通过流 (A Stream)将数据源 (Source)中的数据 (information)输送到程序 (Program)中,或者从程序中接受。

其实流就是一堆数据,这些数以依次发往要去的地方,就像水流一样。

输入时,程序从输入流中抽取字节,输出时,程序将字节添加到输出流里。

在进行输入输出时,数据不会立刻流动到目标(例如从键盘输入),而是被放在一个名为缓冲区的内存块中。


 输入流

例如下面的例子。

#include 

using namespace std;

int main()
{
    cout << "please input words";
    char ch;
    int total = 0;
    while(cin >>ch&&ch!='~')
    {
        if(ch>='0'&&ch<='9')
            total++;
        cout << "now total is " << total << endl;
    }
    cout << total;
    return 0;
}

运行结果

C++——流和输入输出_第1张图片

在回车的那一刻,从缓冲区中发送给程序。

输出时,程序首先填满缓冲区,再把数据块以块的形式传递,并清空缓冲区,以便供下一波输出使用(缓冲区刷新)


输出流

输出流时逐字符输出的,即只会发送字符,例如一个-3.14,不是发送-3.14这个数据块,而是经过ostream类处理,逐字符输出字符  -  3  .  1  4。对于宽字符类型,像汉字,ostream类中也有相应的字符类型(wchar_t)。

从键盘输入每次只能键入一个字符,为什么要有缓冲区呢

这样做为了提高容错,在没有按下回车前可对要发送到输入流中的数据修改。在键入回车的一刻,缓冲区将数据流发送到目标(屏幕或其他。


抽象的解释

源 -> 流  ->  目标


流的作用

无论是进行输入还是输出,都需要将流链接两个目标对于,程序而言,可通过流与文件,显示器,键盘相连。

因此,流充当的类似桥梁的作用。

缓冲区的作用

应该都知道硬盘和内存的关系

流和文件也是对应的这种关系

通常,通过使用缓冲区可以更高效的处理输入和输出。他是一个数据的临时存储工具。磁盘通常以块传输数据(例如512字节),而程序只能一次处理一个字符,二者直连很不合理,所以就放在缓冲区中。以便以合理的方式处理数据。


一些类

管理流和缓冲区的工作C++已经为我们实现好了

streambuf类 为缓冲区提供内存, 并提供了用于填充缓冲区,访问缓冲区中的内容、刷新缓冲区和管理缓冲区内存的 类方法

ios_base类 用于表示流的一般特征,是否可读取,是二进制流还是文本流

ios类 基于ios_base 其中包括了一个指向streambuf对象的指针成员

ostream类 从ios类派生而来,提供了输出方法(类方法)

istream类  从ios类派生而来,提供了输入方法(类方法)

iostream类 基于istream ostream类,因此继承了输入和输出方法

从上面得知,这么平常的输入输出竟然包含了这么多发杂的逻辑!

而cout和cin本质上是两个重载了<<(左移运算符)和>>(右移运算符)的两个iostream类的实例化对象!(在名称空间std中)


cout

<<重载过后用于输出,不再叫左移运算符,而是叫插入运算符。

最简单的输出

int a = 10;
cout << "a is" << a << endl;

 因为<<返回一个ostream对象的引用,可进行递归输出。


它能够识别一些基本数据类型

unsigned char
signed char
char
short
unsigned short
int
unsigned int
long
unsigned long
long long //C++ 11
unsigned long long //C++ 11
float
double
long double

 假如我们要显示一个整形的地址

int main()
{
    int a = 10;
    int *pa = &a;
    cout << pa;
    return 0;
}

非常简单


那一个字符串地址呢

    char str[] ="hello world";
    cout << str;

运行结果

为什么不是地址呢

是因为C++为下列指针也重载了<<

const signed char *
const unsigned char *
const char *
void *

传入字符串的指针具体化的模板(重载的<<)就会输出字符串,要想输出地址强制转换即可

    cout << (void*)str;

 运行结果


其他的ostream类方法

put(char_type __c);
write(const char_type *__s, streamsize __n);

前者用于显示字符,后者用于显示字符串,二者返回 ostream &,因此均可链式调用

    cout.put('A').put('b');
    cout << endl;
    cout.write("hello",5).write("world",10);

运行结果

C++——流和输入输出_第2张图片

合适的情况下也可将int用于put(),自动转换为ASCII码对应的字符


缓冲区的刷新

如果说在等待缓冲区满再发送消息,那为什么程序还会即时发送消息呢?
这与一些机制有关:在屏幕输出时,程序不会等到缓冲区满再发送消息,例如在换行符发送到缓冲区后,程序就会清空并且发送消息,或者在输入即将发生时。即不是先输出在输入,而是将要输入的时候输出并且输入。

控制符flush,也是控制函数,可直接传入cout。

cout << flush;
//or
flush(cout);

使用cout进行格式调整

在C中可用%说明符来控制打印的格式。例如,输出小数点后的两位。

double val = 3.14159;
printf("%.2f",val);

在C++中也有这样的格式控制

首先,在默认情况下

对于char,如果是一个可打印字符,则被用作字符打印在宽度为1的字段中

对于整形,显示十进制,字段宽度刚好容纳数字

对于字符,串显示字段宽度正好为字符串长度

对于浮点,显示6位,并且小数点后的0不显示,使用正常显示还是科学计数法取决于具体的值,指数大于等于6或者小于等于5即显示科学计数法(不同编译器可能不同),显示字段宽度恰好能容纳符号和数字。

特别的:老式的浮点显示方法为,显示小数点后6位,0不显示


可以用cout的类方法,或者函数更改格式或者

再说一下继承关系

ostream继承ios ios继承ios_base

因此,ios_base的方法在ostream的对象中也能使用


1.显示 十进制 十六进制 或者 八进制

使用控制符

dec(cout); //十
hex(cout); //十六
oct(cout); //八

 使用重载了的<<等价调用上面的形式

    cout << dec 
         << hex
         << oct;

示例

    int a = 11;
    cout << dec << a << endl;
    cout << hex << a << endl;
    cout << oct << a << endl;

 运行结果

 注意:这样上述的两种方式都是永久有效(如果不再进行格式调整),而不是临时的(只用于下一项的输出,下一项和下一次是不同的概念)。


2.设置字段宽度

可用于对齐(默认右对齐)

注意:字段宽度的设置,暂时有效,只适用于下一项,不是下一条输出语句,也不是永久

//返回当前设置的宽度,这里的返回指的return value
cout.width();
//设置输出字段宽度并恢复之前的设置,并且返回一个之前设置的宽度值
cout.width(int len);
//比如
#include 

using namespace std;


int main()
{
    char ch = 'a';
    cout.width(5);
    //下面的语句输出10个 字宽,因为被重设置了,但将会输出5
    cout << cout.width(10) << endl;
    cout << ch << endl;
    //正常输出
    cout << ch << endl;
    //set 10
    //len is 10
    cout.width(10);
    int len = cout.width();
    //下面的输出字宽,并且返回默认值0 即return 0,并且输出一项后字宽重新 被设置为0
    cout << "len is " << len << endl;\
    //***len*is* 10 个字宽
    //<< len 正常输出
    cout << ch;
    return 0;
}

运行结果

C++——流和输入输出_第3张图片


 3.填充字符

cout.fill(char);

注意:这个设置永久有效

    cout.fill('*');
    cout.width(10);
    int a =10;
    cout << a << endl << a;

运行结果


4.设置浮点数的显示精度

cout.precision(int);

示例

    double val = 3.14159;
    cout.precision(4);
    cout << val;
    cout << endl << val;

注意:新的精度设置是永久有效(如果不人为改变),在进行截断时会进行四舍五入 

运行结果

C++——流和输入输出_第4张图片


 5.打印末尾的0和小数点 

显示末尾小数点,即使位数够了,也显示 .

所以,可能会有这样的显示 : 20 . 

这个类方法是ios_base中提供的,并且接受一个参数

ios_base::showpoint 是ios_base中定义的一个静态常量,可用于修改设置

同时ios_base还提供了多个类似常量,因此使用常量时用作用域解析符号 : :

cout.setf(ios_base::showpoint);
    double a = 2.00;
    cout << a << endl;
    cout.setf(ios_base::showpoint);
    cout << a;

运行结果

C++——流和输入输出_第5张图片  

可以看一看showpoint的具体值

cout << "ios_base::showpoint value is " << ios_base::showpoint;

运行结果

 但不可直接传入1024作为参数


6.setf函数

应该知道的一些东西

ios_base类有一个保护的数据成员,以位为单位,分别控制着格式的各个方面(把他称作标记),参数是一个fmtflags值,指出要设置哪一位。返回值是类型为fmtflags的数字,指出所有标记以前的设置。如果打算以后恢复格式,则可以保存这个值。

函数原型其一

fmtflags setf(fmtflags);

其中,fmtflags是bitmask(比特位掩码)的一个别名,通过这个命名就可以隐约的感觉出来实现原理——基于掩码

ps:掩码是位运算中的重要知识点

如何传入参数?

如果要设置11位为1,则传入一个bit位11位为1的数字。

这样的传参太令人头疼,但C++已经帮我们实现了

上面的1024转换为2进制数字是什么样子的呢

 10000000000  //二进制表示

当作掩码改变第一位 


一些其他的格式常量

注意:都是永久设置

    ios_base::boolalpha;    //输出bool值,即true和false
    ios_base::showbase;     //对于输出使用C++基数前缀 (0, 0x)
    ios_base::showpoint;    //显示小数点和小数点后面的位数
    ios_base::uppercase;    //对于16进制输出,使用大写字母,用E法表示
    ios_base::showpos;      //在正数前面加上+

想要恢复设置可用调用函数unsetf()函数,恢复其中的某一个设置 


演示

#include 
using namespace std;

int main()
{

    bool p = false;
    const int a = 114514;

    cout.setf(ios_base::boolalpha);
    cout.setf(ios_base::showbase);
    cout << "p(bool) is " << p << endl;

    cout << hex << a << endl;

    double b = 30.45;
    cout.precision(2);
    cout.setf(ios_base::showpoint);

    cout << b << endl;

    cout.setf(ios_base::uppercase);
    cout << hex << a << endl;

    cout.setf(ios_base::showpos);
    cout << dec << a << endl;
    return 0;
}

运行结果

C++——流和输入输出_第6张图片


 第二个setf()接受两个参数,并返回以前设置的值。

//函数原型
fmtflags setf(fmtflags,mask/*fmtflags*/);

第一个参数的作用与上面的版本相同,第二个参数是一个掩码,表示要清除哪些位。

可以这样使用

#include 
using namespace std;
int main()
{
    ios_base::fmtflags temp;
    bool p = false;
    const int a = 114514;

    cout.setf(ios_base::boolalpha);
    cout.setf(ios_base::showbase);
    cout << "p(bool) is " << p << endl;

    cout << hex << a << endl;

    double b = 30.45;
    cout.precision(2);
    //关闭上面开启的码位
    temp = cout.setf(ios_base::showpoint);

    cout << b << endl;

    cout.setf(ios_base::uppercase,temp);
    cout << hex << a << endl;

    cout.setf(ios_base::showpos);
    cout << dec << a << endl;
    return 0;
}

运行结果

C++——流和输入输出_第7张图片


或者也可以恢复到之前的设置

cout.setf(temp,ios_base::adjustfidld);

调用函数unsetf()恢复设置

#include 
using namespace std;
int main()
{
    bool p = false;
    cout.setf(ios_base::boolalpha);
    cout << "before p is " << p << endl;
    cout.unsetf(ios_base::boolalpha);
    cout << "after p is " << p;
}

 运行结果

C++——流和输入输出_第8张图片


                                  C++提供了一些参数

setf()重载版本的一些参数
第二个参数 第一个参数 含   义
ios_base::dec 十进制
ios_base::basefield ios_base::oct 八进制
ios_base::hex 十六进制
ios_base::fixed 定点计数
ios_base::floatfield ios_base::scientific 科学计数
ios_base::left 左对齐
ios_base::adjustfield ios_base::right 右对齐
ios_base::internal

符号/基数前缀左对齐

值又对齐


8.头文件iomanip

提供了一些控制符

例如

setprecision(int);
setfill(char);
setw(int);

见名知义了,不解释。

可以和cout连用

演示

#include 
#include 
using namespace std;
int main()
{
    double a =20.4055;
    cout << setprecision(4) << setfill('#') << setw(10);
    cout << a;
}

运行结果

注意: setprecision(int)函数在位数够的情况下不会显示小数点,在小数点后全是0的情况即使规定也不会去做

double a =20.0045;
cout << setprecision(4) << a;

运行结果


想要显示全用fixed 

int main()
{
    double a =20.00000;
    cout << setprecision(4) << a << endl;
    cout << fixed << a;
}

 运行结果

C++——流和输入输出_第9张图片



9.小数点后几位的表示

浮点是数的含义取决于输出模式。在默认的情况下,它指的是显示的总位数。在定点模式和科学计数模式下,精度指的是小数点后面的位数

原理:使用定点计数法再限制浮点数显示精度即可


法一

    double a =20.4055;
    cout.precision(4);
    cout << fixed  << a;

法二

    cout << fixed << setprecision(4) << a;

还有很多种方法,可以遵循上述原理排列组合。


cin

cin将对象标准输入表示位字节流。通常情况下,通过键盘来生成这种字符流。cin 根据对象接收值的变量的类型,使用其类方法将字符序列转换为所需的类型。

简单的来说,从键盘输入的全看作字符流,也可以理解为字符串,聪明的cin 用他的类方法来判断要把这些数据流转换为什么类型。

int a;
cin >> a;

 例如,我们从键盘输入114514,我们以为输入了一个整形,实际上只是把键盘的输入信息添加到输入流中而已,这种流的本质是字符流。


C++重载了>>(更名为抽取运算符),使之能够识别下面的基本类型

unsigned char &
signed char &
char &
short &
unsigned short &
int &
unsigned int &
long &
unsigned long &
long long  & //C++ 11
unsigned long long & //C++ 11
float &
double &
long double &

比如重载了int的原型

istream & operator >>(int &);

这样处理的不是数据的副本,而是本身,并可以修改其值,正对应可以用cin修改一个变量。

返回istream & 能使cin 链式调用

int a,b;
cin >> a >> b;

可以将hex,oct,dec控制符与cin一起使用,来指定以几进制读取数据

using namespace std;
int main()
{
    int a;
    cin >> hex >> a;
    cout << a;
}

运行结果

C++——流和输入输出_第10张图片


 cin与指针

istream类还为下列字符指针类型重载了>>运算符。

signed char *
char *
unsigned char *

使得cin能用字符指针读取字符串


演示

int main()
{
    char str[10];
    cin >> str;
    cout << str;
}

运行结果

C++——流和输入输出_第11张图片


cin如何检查输入

cin查看输入流的方式是:逃过空白(空格,回车,制表符等),直到遇到非空白字符,再从输入流中抽取。

>>运算符将读取一个指定类型的数据。也就是说,他读取从非空白字符开始,到与目标类型不匹配的第一个字符之间的全部内容。

如果输入类型不匹配,会返回0,于是可以有这种语法

while(cin >> a);

读取到不符合a数据类型的数据将跳出循环。


流状态,对输入流的进一步探索

cin或者cout对象包含一个描述流状态的数据成员(就是一个变量)(从ios_base继承而来),流状态由3个ios_base元素组成:其中每个元素都是一位

eofbit

cin读取到文件结尾的时候,将设置eofbit

badbit

在一些无法诊断的失败破坏流时,设置badbit

failbit

未能读取到预期字符时,或者I/O失败,设置failbit

上述3个位全部为0的时候,表示输入顺利。

可以看一看他们对应的掩码

    cout << ios_base::badbit << ios_base::eofbit << ios_base::failbit;

运行结果

分别对应的二进制

ios_base::badbit         mask: 001

ios_base::eofbit          mask: 010

ios_base::failbit           mask: 100


可以检查流状态,并利用这些信息进行一些程序处理

成员 描述
eofbit 如果到达文件结尾,设置为1
badbit 如果流被破坏,设置为1.例如文件损坏
failbit 如果输入未能读取预期的字符或者输出操着没有写入预期的字符,设置为1
goodbit 另一种表示流的方法
good() 如果流可以使用( 000 ),则返回true
eof() 如果eofbit被设置,返回true
bad() 如果badbit被设置,返回true
fail() 如果failbit被设置,返回true
rdstate() 返回流状态
exceptions() 返回一个位掩码,指出哪些标记导致异常
exceptions(iostate ex)

设置哪些状态将导致clear()引发异常;例如,如果ex是eofbit,并且eofbit已经被设置

则将会引发异常

clear(iostate s) 流状态设置为s,default = goodbit,并将其他位清除
setstate(iostate s) 调用( clear(rdstate|s) )。单独设置s对应的位,其余位不变

1.设置状态

下面的代码将会使流状态重新设置

cin.clear(); //default argument is goodbit

或者用上面介绍的方法设置某一个位

为什么需要重新设置流状态呢?
最常见的理由是,输入不匹配或者达到文件结尾时,重新打开输入流,因为这时候一些位已经被设置,会影响流的正常读取。当然,具体的情况具体分析。


演示

int main()
{
    int a;
    int n = 5;
    int sum = 0;
    while(n--)
    {
        cin >> a;
        if(!cin.good())
        {
            cout << "输入流错误\n";
            //break;
        }else
            sum += a;
        cout << "sum is " << sum << endl;
    }
    cin >> a;
}

运行结果

C++——流和输入输出_第12张图片

可以看见,因为输入流错误,不能再进行输入,只能等待循环结束,并且,循环外的输入语句也没有执行。可用clear()重新设置输入流,但还是需要一些处理,下面会说到。


I/O与异常

假设某个输入函数设置了eofbit,这是否会引发程序异常呢?

在默认情况下,这是不行的,因为exceptions(iostate ex)其中的ex默认位goodbit

如果更改了设置,使之引发了异常,则将引发ios_base::failure,从srd::expction类派生而来,因此有一个what()方法。

int main()
{
    int sum = 0;
    int a;
    cin.exceptions(ios_base::failbit);
    try{
        while(cin >> a)
        {
            sum += a;
        }
    } catch (ios_base::failure & bf) {
        cout << bf.what() << endl;
    }
    cout << "sum is " << sum;
}

运行结果

C++——流和输入输出_第13张图片


流状态的影响

 对于读入数据类型错误的情况,输入流被设置了failbit,理应用clear()重置。

using namespace std;
int main()
{
    int a;
    int n = 5;
    int sum = 0;
    while(n--)
    {
        cin >> a;
        if(!cin.good())
        {
            cout << "输入流错误,已经重新设置\n";
            cin.clear();
/*            while(!isspace(cin.get()))
            {
                continue;
            }*/
        }else
            sum += a;
        cout << "sum is " << sum << endl;
    }
    cin >> a;
}

运行结果

C++——流和输入输出_第14张图片


这是为什么呢?
原因是e被一直留在了输入流中

执行第一次的显示错误消息后重新进行cin>>a,此时读取到的还是e,因为类型不同,e一直没被读取,就一直进行上述循环。

将代码中的注释打开,读取到空白字符,即可重新输入。

运行结果

C++——流和输入输出_第15张图片  


其他的istream类方法

1.单字符输入

get(char &)             //返回一个istream & ,因此可以递归使用

get(void)                 //读取字符并且返回其对应的整形,不能递归使用

不跳过空白的字符读入

 顺便一说,下面的代码将永远不能跳出循环,因为cin忽略输入流中的空白字符

    char ch;
    cin >> ch;
    while(ch != '\n')
    {
        //do something
    }

但下面的代码可以,cin.get(ch)不跳过空白字符

    char ch;
    while(cin.get(ch)&&ch!='\n')
    {
        //do something
    }

可用这样的形式读取

cin.get(ch).get();

将会丢弃第二个输入字符


演示

using namespace std;
int main()
{
    string str;
    char ch;
    int i=0;
    while(cin.get(ch).get()&&ch!='\n')
    {
        str += ch;
    }
    cout << str;
}

运行结果 

C++——流和输入输出_第16张图片


cin.get(void)达到文件结尾反回EOF,因此可以这样使用

    while(ch = cin.get() != EOF)
    {
        //do something
    }

2.读入单个字符的选择

如果要读入菜单选项等,使用跳过空白符号的cin>> 更加合适

如果希望检查输入流中的每一个字符,应该使用get()函数的两个版本

其中get(ch)的接口更佳,get(void)的优点是方便C程序到C++程序的转换。


3.字符串读入

四个函数

istream & get(char *, int, char);

istream & get(char *, int);

istream & getline(char *, int, char);

istream & getline(char *, int);

第一个参数是用于存放字符串的地址

第二个参数是表示读取的长度+1(存放 '\0' )

第三个参数用于表示分界符

上述函数均在读取最大数目的字符或遇到换行符后为止

 get()和getline()的主要区别是,前者将换行符留在输入流中,而后者从输入流中读取换行并且舍弃

ignoer()成员函数

该函数接受两个参数:一个是数字,指定要读取的最大字符数,另一个参数是字符,用作分界符号。

函数功能,丢且接下来输入的字符长度为第一个参数,直到遇到分界符或者读满。

 演示


using namespace std;
int main()
{
    string str;
    char str1[12];
    char ch;
    //cin.get(str,12) //error str isn't a char
    cout << "use cin.get input str1" << endl;
    cin.get(str1,12);
    cout << "now str1 is " << str1 << endl;
    ch = cin.get();
    if(ch == '\n')
        cout << "next char is \\n" << endl;
    cout << "use function ignore(10,'\\n')" << endl;
    cin.ignore(10,'\n');
    cout << "use cin.getline input str1" << endl;
    cin.getline(str1,12);
    cout << "now str1 is " << str1 << endl;
    cin.get(ch);
    if(ch == '\n')
        cout << "next char is\\n";
    else
        cout << "next char not is \\n";
    return 0;
}

一些运行结果

C++——流和输入输出_第17张图片


use cin.get input str1
hello world
now str1 is hello world
next char is \n
use function ignore(10,'\n')
1234567890
use cin.getline input str1
now str1 is /*\n*/

next char is \n

 上面的空行是str1本身是回车输出回车,我们又输入了一个回车的结果


字符串输入错误

getline()和get()与其他输入函数一样,遇到文件结尾时将设置eofbit,流被破坏设置badbit。

无输入或者输入超限的情况下将设置failbit

其中,如果不能从流中抽取字符则把空字符放在输入字符串中,并使用setstate设置failbit。

不能从流中抽取字符的情况下有两种

第一种是到达了文件尾

对于get(char *, int)来说(不是getline()),另一种可能是读入了空行

 对上面的补充

getline()读入了空行也不会设置failbit,而是读入换行符并将其舍弃


演示

    char str1[12];
    cin.getline(str1,5);
    cout << str1 << endl;
    cin >> str1;

 运行结果

C++——流和输入输出_第18张图片

 可以看见,不能再进行读取了


    char ch;
    char str1[12];
    cin.get(str1,10);
    cout << "str1 is " << str1 << endl;
    cin.get(ch);
    cout << "ch is " << ch << endl;

运行结果

C++——流和输入输出_第19张图片

 可以看见str1没有读入换行,ch也是乱码


如果想让getline()读入空行结束,可以这样书写

    char str1[12];
    while(cin.getline(str1,12)&&str1[0]!='\0')
    {
        cout << str1 << endl;
    }

运行结果

C++——流和输入输出_第20张图片

 注意输入时不要超过getline中的参数限制

其他的istrream类方法


1.read()

读取指定数目的字节,不会再末尾加上空字符'\0',不是设计专门用来键盘读入的,常与ostream wrtie组合使用来读写文件,反回istream &,可链式调用


2.peek()

反回输入流中的下一个字符,但不抽取

演示

    char ch;
    char str[10];
    int i= 0;
    while((ch = cin.peek()) != '.' && ch!='\n')
        str[i++] = ch = cin.get();
    cout << "str is " << str << endl;
    cin.get(ch);
    cout << "next char is " << ch;

运行结果

C++——流和输入输出_第21张图片


3.gcount()

返回最后一个非格式化抽取方法(不是cin>>)读取的字符数。

演示

    char ch;
    char str[10];
    cin >> ch;
    while(ch!='\n')
    {
        cin.get(ch);
    }
    cin.getline(str,10);
    cout << cin.gcount();

 运行结果

C++——流和输入输出_第22张图片

为什么是7个呢

因为换行符也是一个字符


4.putback()

将一个字符头差插到输入流中 ,反回istream &

演示

    char str[10];
    cin.putback('1');
    cin >> str;
    cout << str;

运行结果

C++——流和输入输出_第23张图片

你可能感兴趣的:(C++,c++,流处理)