c++输入输出流

Posted 2023-04-03 aoeh

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c++输入输出流相关的知识，希望对你有一定的参考价值。

文章目录

前言
一、流
- 1.iostream 库的头文件
- 2.输入/输出流的类和对象
二、输出流
- 使用成员函数put进行字符输出
三、输入流
- 1.get函数
- 2. getline
四、使用read、write和gcount的非格式化的I/O
五、流操纵符

前言

最近在准备复试，学习c++，就当作是学习笔记了

一、流

C++的I/O是以一连串的字节流的方式进行的。在输入操作中，字节从设备(例如，键盘、磁盘驱动器、网络连接等)流向内存。在输出操作中，字节从内存流向设备(例如，显示屏、打印机、磁盘驱动器、网络连接等)。
应用程序通过字节传达信息。字节可以组成字符、原始数据、图形图像、数字语音、数字视频或者任何应用程序所需要的其他信息。系统I/O结构应该能持续可靠地将字节从设备传输到内存,反之亦然。这种传输一般包含一些机械运动，例如，磁盘或磁带的旋转，或者键盘的敲击。数据传输所花费的时间远远大于处理器内部处理数据所花费的时间。所以I/O操作需要仔细计划和协调，以保证最优的性能。
C++同时提供“低层次的”和“高层次的”I/O功能。

低层次的I/O功能(也就是非格式化的I/O)指定字节应从设备传输到内存还是从内存传输到设备。这种传输通常针对单个字节。这种低层次的L/0提供速度快、容量大的传输,但是对程序员来说并不方便。
高层次的I/O(也就是格式化的I/O)。在这种输出方式中字节被组成了有意义的单元，例如整数、浮点数、字符、字符串和用户定义类型。除了大容量的文件处理之外，这种面向类型的方法能够满足绝大多数的I/O处理。

1.iostream 库的头文件

<iostream >头文件定义了cin 、 cout 、cerr和 clog对象，分别对应于标准输入流、标准输出流、无缓冲的标准错误流和有缓冲的标准错误流。同时还提供了非格式化和格式化的LO服务。

<iomanip>头文件中声明了参数化流操纵符(例如setw和 setprecision)用于向格式化I/O提供有用的服务。
<fstream>头文件声明了文件处理服务。

2.输入/输出流的类和对象

预定义对象cin是一个 istream实例，并且“被连接到”(或者“被绑定到”)标准输入设备,通常是键盘。在下面的语句中,流提取运算符(>>)用于使一个整型变量 grade的值(假设grade已经被声明为int变量)从cin输入到内存:
cin >> grade;
注意，由编译器确定grade的数据类型,并选择适当的流提取运算符重载。假设grade已经被正确地声明,流提取运算符不需要附加的类型信息(例如，像C语言的I/O的方式)。重载>>运算符用来输入内置类型、字符串和指针的值。
预定义对象cout是一个ostream实例，并且“被连接到”标准输出设备，通常是显示屏。在下面的语句中，使用流插人运算符(<<)将变量grade的值从内存输出到标准输出设备:
cout << grade
注意，也是由编译器确定grade的数据类型(假设grade已经被正确地声明)并且选择合适的流插入运算符，因此流插入运算符也同样不需要附加类型信息。重载<<运算符用来输出内置类型、字符串和指针的值。
预定义对象cerr是一个ostream 实例，并且“被连接到”标准错误设备。对象cerr的输出是无缓冲的。这意味着每个针对cerr的流插入的输出必须立刻显示，这对于迅速提示用户发生错误非常合适。
预定义对象clog是一个ostream 实例，并且“被连接到"标准错误设备。clog 的输出是有缓冲的。这意味着每个针对clog中的流插入的输出将保存在缓冲区中，直到缓冲区填满或是被清空才会输出。在操作系统课程上曾讨论过,使用缓冲技术可以加强I/O的性能。

二、输出流

ostream提供了格式化的和非格式化的输出功能。输出功能包括使用流插入运算符(<<)执行标准数据类型的输出;通过成员函数put进行字符输出;通过成员函数write进行非格式化的输出；十进制、八进制、十六进制格式的整数输出；具有不同精确度的浮点数的输出，或是具有强制小数点的浮点数的输出，以及以科学记数和定点小数格式的输出;指定宽度数据的输出;用指定符号填充数据域的输出；以及使用科学记数和十六进制符号表示的大写字母的输出。

使用成员函数put进行字符输出

可以使用成员函数put输出字符。例如,语句
cout.put(“A’);
显示单个字符A。put也可以级联使用。例如,语句
cout.put( ‘A’ ).put( ‘\\n’ );
输出一个字母A，接着输出一个换行符。前面的语句就以像使用<<一样的方式执行，因为点运算符(.)是从左向右执行，put 成员函数给ostream对象( cout)返回一个引用,该对象接受了put的调用。也可以用代表一个ASCII值的数字表达式作为参数来调用put成员函数，例如，语句
cout.put( 65 );
的输出也是A。

三、输入流

1.get函数

三种get

没有实参的成员函数 get从指定流输入一个字符(包括空白字符及其他非图形字符，比如表示文件尾的键序列等)，并将这个值作为函数调用的返回值返回。get函数在遇到流中的文件尾时返回EOF值。
带一个字符引用参数的get 函数将输入流中的下一个字符(即使它是一个空白字符)输人，并将它存诸在其引用的字符参数内。在调用这个版本的get 函数时将给调用它的istream对象返回一个引用。
get 函数拥有三个参数:一个字符数组、一个数组长度限制和一个分隔符(默认值为‘\\n’)。这个函数可以从输入流读取多个字符，它可以读取“数组最大长度-1"个字符后终止，也可以遇到分隔符就终止。在程序中，插入一个空字符用来结束字符数组中的输入字符串，字符数组在程序中作为缓冲区。**分隔符没有放置在字符数组中，而是保留在输入流中(分隔符是下一个被读取的字符)。**因此,第二次 get 函数调用所得的结果将是个空行,除非将分隔符从输人流中移出(可以使用cin.ignore( ))。

2. getline

成员函数getline操作与第三个版本的成员函数get类似，在该行所存储的字符数组的末尾插入一个空字符。getline函数从流中移除分隔符(也就是读取该字符然后丢弃)，没有将其放在字符数组内存储。

四、使用read、write和gcount的非格式化的I/O

非格式化的输入/输出使用的分别是istream与 ostream 的成员函数read和 write。成员函数read将一定数量的字节读入到字符数组中，
成员函数write则从字符数组中输出字节。这些字节没有经过任何格式化，它们就像原始字节一样输入或输出。例如,命令
char buffer[ ] =“HAPPY BIRTHDAY”;
cout.write( buffer，10);
输出 buffer数组中的前10个字符(包括空字符,任何一个空字符都会导致使用cout和<<进行输出操作的终止)。调用
cout.write(“ABCDEFGHIJKLMNOPQRSTUVWXYZ”，10);
显示字母表的前10个字母。
成员函数read将指定数量的字符读入到字符数组中。当读取的字符数量少于指定数量时，failbit将被设置

五、流操纵符

浮点精度(precision,setprecision)

可以使用流操纵符setprecision或ios_base的成员函数 precision来控制浮点数的精度(也就是小数点右边的位数)。调用这两者之中的任何一个都可以改变输出精度，这将影响后面所有的输出操作，直到下一个设置精度操作被调用为止。调用无参数的成员函数 precision将返回当前的精度设置(这样可以在不再使用“黏性的"设置时，重新使用原来的精度设置)。

域宽( width, setw)

成员函数width(基类是ios_base)可以设置域宽(也就是输出值所占的字符位数或是可输入的最大字符数)并且返回原先的域宽。如果输出值的宽度比域宽小,则插入填充字符进行填充。宽度大于指定宽度的值不会被截短，会将整个值都打印出来。不含参数的width函数将返回当前域宽。
宽度设置只适用于下一次输入或输出(也就是说宽度设置并不是“黏性的”)，之后的宽度被隐式地设置为0(也就是输入和输出将使用默认设置)。一次宽度设置适用于所有后续输出的假设是逻辑错误。

对齐(left、right 和 internal)

流操纵符left和right分别使域左对齐并在其右边填充字符,或者右对齐并在其左边填充字符。填充字符由成员函数fill或是参数化流操纵符setill指定
流操纵符internal 表示数字的符号(或是使用showbase流操纵符显示的基数)应当左对齐，同时数字的数值部分应右对齐，而中间的部分则使用填充字符填充。

内容填充( fill , setfill)

成员函数fill 指定对齐域的填充字符。如果没有字符被指定，则使用空格符填充。fill函数返回设定之前的填充字符。setill操纵符也用于设置填充字符。

C++学习笔记C++输入输出流

文章目录

C++输入流和输出流（超级详细）
- C++输入流和输出流
C++ cout.put()：输出单个字符
C++ cout.write()：输出字符串
C++ cout.tellp()和cout.seekp()方法详解
- C++ tellp()成员方法
- C++ seekp()成员方法
C++ cout格式化输出（超级详细）
- C++ cout成员方法格式化输出
- 使用流操纵算子格式化输出
C++怎样对输入输出重定向？（3种方法）
- C++ freopen()函数实现重定向
- C++ rdbuf()函数实现重定向
- C++通过控制台实现重定向
C++如何管理输出缓冲区？
- 刷新输出缓冲区
- unitbuf 操作符
- - - 警告：如果程序崩溃，输出缓冲区不会被刷新
- 关联输入和输出流
cin.get()：C++读取单个字符
cin.getline()：C++读入一行字符串（整行数据）
C++如何跳过（忽略）指定字符？
C++怎样查看输入流中的下一个字符？
C++ cin是如何判断输入结束（读取结束）的？
- cin 判断控制台（键盘）读取结束
- cin 判断文件读取结束
- 答疑解惑
C++处理输入输出错误
- 实例

http://c.biancheng.net/cplus/

C++输入流和输出流（超级详细）

本教程一开始就提到，C++ 又可以称为“带类的 C”，即可以理解为 C++ 是 C 语言的基础上增加了面向对象（类和对象）。在此基础上，学过 C 语言的读者应该知道，它有一整套完成数据读写（I/O）的解决方案：

使用 scanf()、gets() 等函数从键盘读取数据，使用 printf()、puts() 等函数向屏幕上输出数据；
使用 fscanf()、fgets() 等函数读取文件中的数据，使用 fprintf()、fputs() 等函数向文件中写入数据。

要知道，C 语言的这套 I/O 解决方案也适用于 C++ 程序，但 C++ 并没有“偷懒”，它自己独立开发了一套全新的 I/O 解决方案，其中就包含大家一直使用的 cin 和 cout。前面章节中，我们一直在用 cin 接收从键盘输入的数据，用 cout 向屏幕上输出数据（这 2 个过程又统称为“标准 I/O”）。除此之外，C++ 也对从文件中读取数据和向文件中写入数据做了支持（统称为“文件 I/O”）。

本质上来说，C++ 的这套 I/O 解决方案就是一个包含很多类的类库（作为 C++ 标准库的组成部分），这些类常被称为“流类”。

C++ 的开发者认为数据输入和输出的过程也是数据传输的过程，数据像水一样从一个地方流动到另一个地方，所以 C++ 中将此过程称为“流”，实现此过程的类称为“流类”。

图 1 展示了 C++ 中用于实现数据输入和输出的这些流类以及它们之间的关系：

图 1 C++类库中的流类

其中，图中的箭头代表各个类之间的派生关系。比如，ios 是所有流类的基类，它派生出 istream 和 ostream。特别需要指出的是，为了避免多继承的二义性，从 ios 派生出 istream 和 ostream 时，均使用了 virtual 关键字（虚继承）。

图 1 中这些流类各自的功能分别为：

istream：常用于接收从键盘输入的数据；
ostream：常用于将数据输出到屏幕上；
ifstream：用于读取文件中的数据；
ofstream：用于向文件中写入数据；
iostream：继承自 istream 和 ostream 类，因为该类的功能兼两者于一身，既能用于输入，也能用于输出；
fstream：兼 ifstream 和 ofstream 类功能于一身，既能读取文件中的数据，又能向文件中写入数据。

本章仅讲解实现标准 I/O 操作的 istream、ostream 和 iostream 类，有关实现文件 I/O 操作的流类放到后续章节讲解。

C++输入流和输出流

在前面章节的学习中，只要涉及输入或者输出数据，我们立马想到的就是 cin 和 cout。其实，cin 就是 istream 类的对象，cout 是 ostream 类的对象，它们都声明在头文件中，这也解释了“为什么在 C++ 程序中引入就可以使用 cin 和 cout”（当然使用 cin 和 cout，还需要声明 std 命名空间）。

除此之外，头文件中还声明有 2 个 ostream 类对象，分别为 cerr 和 clog。它们的用法和 cout 完全一样，但 cerr 常用来输出警告和错误信息给程序的使用者，clog 常用来输出程序执行过程中的日志信息（此部分信息只有程序开发者看得到，不需要对普通用户公开）。

cout、cerr 和 clog 之间的区别如下：

cout 除了可以将数据输出到屏幕上，通过重定向（后续会讲），还可以实现将数据输出到指定文件中；而 cerr 和 clog 都不支持重定向，它们只能将数据输出到屏幕上；
cout 和 clog 都设有缓冲区，即它们在输出数据时，会先将要数据放到缓冲区，等缓冲区满或者手动换行（使用换行符 ‘\\n’ 或者 endl）时，才会将数据全部显示到屏幕上；而 cerr 则不设缓冲区，它会直接将数据输出到屏幕上。

除了以上 2 点特性上的不同之外，cerr、clog 和 cout 没有任何不同。之所以我们常用 cout，是因为 cerr 和 clog 有各自不同的适用场景。以 cerr 为例，一旦程序某处使用 cerr 输出数据，我们自然而然地会认为此处输出的是警告或者错误信息。

值得一提的是，类似 cin、cout、cerr 和 clog 这样，它们都是 C++ 标准库的开发者创建好的，可以直接拿来使用，这种在 C++ 中提前创建好的对象称为内置对象。实际上，头文件中还声明有处理宽字符的 4 个内置对象，分别为 wcin、wcout、wcerr 以及 wclog，由于不是本节重点，这里不再对它们做详细讲解。

如下程序演示了 cin、cout、cerr 和 clog 的基本用法：

#include <iostream>
#include <string>
int main() {
    std::string url;
    std::cin >> url;
    std::cout << "cout：" << url << std::endl;
    std::cerr << "cerr：" << url << std::endl;
    std::clog << "clog：" << url << std::endl;
    return 0;
}

程序执行结果为：

http://c.biancheng.net
cout：http://c.biancheng.net
cerr：http://c.biancheng.net
clog：http://c.biancheng.net

注意，此程序中并没有考虑 cerr 和 clog 各自特有的含义，这里仅是为了演示 cerr 和 clog 的基础用法，不建议读者这样使用。另外，如果程序中 std 命名空间提前声明，则所有的 std:: 可以省略。

它们的用法远不止此，istream 和 ostream 类提供了很多实用的函数，cin、cout、cerr 和 clog 作为类对象，当然也能调用。

表 1 罗列了 cin 对象常用的一些成员方法以及它们的功能：

成员方法名	功能
getline(str,n,ch)	从输入流中接收 n-1 个字符给 str 变量，当遇到指定 ch 字符时会停止读取，默认情况下 ch 为 ‘\\0’。
get()	从输入流中读取一个字符，同时该字符会从输入流中消失。
gcount()	返回上次从输入流提取出的字符个数，该函数常和 get()、getline()、ignore()、peek()、read()、readsome()、putback() 和 unget() 联用。
peek()	返回输入流中的第一个字符，但并不是提取该字符。
putback©	将字符 c 置入输入流（缓冲区）。
ignore(n,ch)	从输入流中逐个提取字符，但提取出的字符被忽略，不被使用，直至提取出 n 个字符，或者当前读取的字符为 ch。
operator>>	重载 >> 运算符，用于读取指定类型的数据，并返回输入流对象本身。

表 2 罗列了 cout、cerr 和 clog 对象常用的一些成员方法以及它们的功能：

成员方法名	功能
put()	输出单个字符。
write()	输出指定的字符串。
tellp()	用于获取当前输出流指针的位置。
seekp()	设置输出流指针的位置。
flush()	刷新输出流缓冲区。
operator<<	重载 << 运算符，使其用于输出其后指定类型的数据。

举个例子：

#include <iostream>
using namespace std;
int main() {
    char url[30] = {0};
    //读取一行字符串
    cin.getline(url, 30);
    //输出上一条语句读取字符串的个数
    cout << "读取了 "<<cin.gcount()<<" 个字符" << endl;
    //输出 url 数组存储的字符串
    cout.write(url, 30);
    return 0;
}

程序执行结果为：

http://c.biancheng.net
读取了 23 个字符
http://c.biancheng.net

注意，表 1 和表 2 中仅罗列了 istream 和 ostream 类中常用的一些成员方法，关于这些方法的具体用法，后续章节会做详细介绍。

C++ cout.put()：输出单个字符

通过前面的学习我们知道，C++ 程序中一般用 ostream 类的 cout 输出流对象和 << 输出运算符实现输出，并且 cout 输出流在内存中有相应的缓冲区。但有时用户还有特殊的输出需求，例如只输出一个字符，这种情况下可以借助该类提供的 put() 成员方法实现。

put() 方法专用于向输出流缓冲区中添加单个字符，其语法格式如下：

ostream＆put(char c);

其中，参数 c 为要输出的字符。

可以看到，该函数会返回一个 ostream 类的引用对象，可以理解返回的是 cout 的引用。这意味着，我们可以像下面这样使用 put() 函数：

cout.put(c1).put(c2).put(c3);

因为 cout.put(c1) 向输出流缓冲区中添加 c1 字符的同时，返回一个引用形式的 cout 对象，所以可以继续用此对象调用 put(c2)，依次类推。

【实例1】输出单个字符 a。

cout.put(‘a’);

调用该方法的结果是在屏幕上显示一个字符 a。

【实例2】put() 函数的参数可以是字符或字符的 ASCII 代码（也可以是一个整型表达式）。

cout.put(65 + 32);
cout.put(97);

上面两行代码都输出字符 a，因为 97 是字符 a 的 ASCII 代码。

【实例3】可以在一个语句中连续调用 put() 函数，例如：

cout.put(71).put(79).put(79). put(68).put(’\\n’);

在屏幕上显示GOOD。

【实例4】有一个字符串 “ten.gnehcnaib.c//:ptth”，要求把它们按相反的顺序输出。

#include <iostream>
#include <string>
using namespace std;
int main(){
    string str = "ten.gnehcnaib.c//:ptth";
    for (int i = str.length() - 1; i >= 0; i--) {
        cout.put(str[i]);  //从最后一个字符开始输出
    }
    cout.put('\\n');
    return 0;
}

运行结果：

http://c.biancheng.net

除了使用 cout.put() 函数输出一个字符外，还可以用 putchar() 函数输出一个字符。putchar() 函数是C语言中使用的，在 <stdio.h> 头文件中定义，C++保留了这个函数，在头文件中定义。

C++ cout.write()：输出字符串

《C++ cout.put()》一节中，讲解了 ostream 类提供的 put() 成员方法的用法，其用于向输出流缓冲区中添加要输出的单个字符。而在某些场景中，我们还需要输出指定的字符串，这时可以使用 ostream 类提供的 write() 成员方法。

write() 成员方法专用于向输出流缓冲区中添加指定的字符串，初学者可以简单的理解为输出指定的字符串。其语法格式如下：

ostream＆write（const char * s，streamsize n）;

其中，s 用于指定某个长度至少为 n 的字符数组或字符串；n 表示要输出的前 n 个字符。

可以看到，该函数会返回一个 ostream 类的引用对象，可以理解返回的是 cout 的引用。这意味着，我们可以像下面这样使用 write() 方法：

cout.write(c1, 1).write(c2, 2).write(c3, 3);

因为 cout.write(c1, 1) 向输出流缓冲区中添加 c1 字符串中第 1 字符的同时，会返回一个引用形式的 cout 对象，所以可以继续用此对象调用 write(c2, 2)，向输出流缓冲区添加 c2 字符串中前 2 个字符，依次类推。

【例 1】输出 “http://c.biancheng.net/cplus/” 字符串中前 4 个字符。

#include <iostream>
using namespace std;
int main() {
    const char * str = "http://c.biancheng.net/cplus/";
    cout.write(str, 4);
    return 0;
}

程序执行结果为：

http

【例 2】连续使用 write() 方法。

#include <iostream>
using namespace std;
int main() {
    cout.write("http://", 7).write("c.biancheng.net", 15).write("/cplus/", 7);
    return 0;
}

程序执行结果为：

http://c.biancheng.net/cplus/

C++ cout.tellp()和cout.seekp()方法详解

通过前面章节的学习我们知道，无论是使用 cout 输出普通数据，用 cout.put() 输出指定字符，还是用 cout.write() 输出指定字符串，数据都会先放到输出流缓冲区，待缓冲区刷新，数据才会输出到指定位置（屏幕或者文件中）。

值得一提的是，当数据暂存于输出流缓冲区中时，我们仍可以对其进行修改。ostream 类中提供有 tellp() 和 seekp() 成员方法，借助它们就可以修改位于输出流缓冲区中的数据。

C++ tellp()成员方法

首先，tellp() 成员方法用于获取当前输出流缓冲区中最后一个字符所在的位置，其语法格式如下：

streampos tellp();

显然，tellp() 不需要传递任何参数，会返回一个 streampos 类型值。事实上，streampos 是 fpos 类型的别名，而 fpos 通过自动类型转换，可以直接赋值给一个整形变量（即 short、int 和 long）。也就是说，在使用此函数时，我们可以用一个整形变量来接收该函数的返回值。

注意，当输出流缓冲区中没有任何数据时，该函数返回的整形值为 0；当指定的输出流缓冲区不支持此操作，或者操作失败时，该函数返回的整形值为 -1。

在下面的样例中，实现了借助 cout.put() 方法向 test.txt 文件中写入指定字符，由于此过程中字符会先存入输出流缓冲区，所以借助 tellp() 方法，我们可以实时监控新存入缓冲区中字符的位置。

举个例子：

#include <iostream> //cin 和 cout
#include <fstream> //文件输入输出流
int main() {
    //定义一个文件输出流对象
    std::ofstream outfile;
    //打开 test.txt，等待接收数据
    outfile.open("test.txt");
    const char * str = "http://c.biancheng.net/cplus/";
    //将 str 字符串中的字符逐个输出到 test.txt 文件中，每个字符都会暂时存在输出流缓冲区中
    for (int i = 0; i < strlen(str); i++) {
        outfile.put(str[i]);
        //获取当前输出流
        long pos = outfile.tellp();
        std::cout << pos << std::endl;
    }
    //关闭文件之前，刷新 outfile 输出流缓冲区，使所有字符由缓冲区流入test.txt文件
    outfile.close();
    return 0;
}

注意，此例中涉及到了文件操作的相关知识，初学者仅需借助注释了解程序的执行脉络即可，不需要研究具体实现细节。有关文件操作，后续章节会做详细讲解。

读者可自行运行此程序，其输出结果为 1~29。这意味着，程序中每次向输出流缓冲区中放入字符时，pos 都表示的是当前字符的位置。比如，当将 str 全部放入缓冲区中时，pos 值为 29，表示的是最后一个字符 ‘/’ 位于第 29 个位置处。

C++ seekp()成员方法

seekp() 方法用于指定下一个进入输出缓冲区的字符所在的位置。

举个例子，假设当前输出缓冲区中存有如下数据：

http://c.biancheng.net/cplus/

借助 tellp() 方法得知，最后一个 ‘/’ 字符所在的位置是 29。此时如果继续向缓冲区中存入数据，则下一个字符所在的位置应该是 30，但借助 seekp() 方法，我们可以手动指定下一个字符存放的位置。

比如通过 seekp() 指定下一个字符所在的位置为 23，即对应 “cplus/” 部分中字符 ‘c’ 所在的位置。此时若再向缓冲区中存入 “python/”，则缓冲区中存储的数据就变成了：

http://c.biancheng.net/python/

显然，新的 “python/” 覆盖了原来的 “cplus/”。

seekp() 方法有如下 2 种语法格式：

//指定下一个字符存储的位置
ostream& seekp (streampos pos);
//通过偏移量间接指定下一个字符的存储位置   
ostream& seekp (streamoff off, ios_base::seekdir way);

其中，各个参数的含义如下：

pos：用于接收一个正整数；、
off：用于指定相对于 way 位置的偏移量，其本质也是接收一个整数，可以是正数（代表正偏移）或者负数（代表负偏移）；
way：用于指定偏移位置，即从哪里计算偏移量，它可以接收表 1 所示的 3 个值。

模式标志	描述
ios::beg	从文件头开始计算偏移量
ios::end	从文件末尾开始计算偏移量
ios::cur	从当前位置开始计算偏移量

同时，seekp() 方法会返回一个引用形式的 ostream 类对象，这意味着 seekp() 方法可以这样使用：

cout.seekp(23) << "当前位置为：" << cout.tellp();

举个例子：

#include <iostream> //cin 和 cout
#include <fstream> //文件输入输出流
using namespace std;
int main() {
    //定义一个文件输出流对象
    ofstream outfile;
    //打开 test.txt，等待接收数据
    outfile.open("test.txt");
    const char * str = "http://c.biancheng.net/cplus/";
    //将 str 字符串中的字符逐个输出到 test.txt 文件中，每个字符都会暂时存在输出流缓冲区中
    for (int i = 0; i < strlen(str); i++) {
        outfile.put(str[i]);
        //获取当前输出流
       
    }
    cout << "当前位置为：" << outfile.tellp() << endl;
    //调整新进入缓冲区字符的存储位置
    outfile.seekp(23);  //等价于：
                        //outfile.seekp(23, ios::beg);
                        //outfile.seekp(-6, ios::cur);
                        //outfile.seekp(-6, ios::end);
   
    cout << "新插入位置为:" << outfile.tellp() << endl;
    const char* newstr = "python/";
    outfile.write("python/", 7);
    //关闭文件之前，刷新 outfile 输出流缓冲区，使所有字符由缓冲区流入test.txt文件
    outfile.close();
    return 0;
}

读者可自行执行此程序，会发现最终 test.txt 文件中存储的为 “http://c.biancheng.net/python/”。

C++ cout格式化输出（超级详细）

在某些实际场景中，我们经常需要按照一定的格式输出数据，比如输出浮点数时保留 2 位小数，再比如以十六进制的形式输出整数，等等。

对于学过 C 语言的读者应该知道，当使用 printf() 函数输出数据时，可以通过设定一些合理的格式控制符，来达到以指定格式输出数据的目的。例如 %.2f 表示输出浮点数时保留 2 位小数，%#X 表示以十六进制、带 0X 前缀的方式输出整数。

关于 printf() 函数支持的格式控制符，更详细的讲解，可阅读《C语言数据输出大汇总》一节，这里不做详细赘述。

C++ 通常使用 cout 输出数据，和 printf() 函数相比，cout 实现格式化输出数据的方式更加多样化。一方面，cout 作为 ostream 类的对象，该类中提供有一些成员方法，可实现对输出数据的格式化；另一方面，为了方面用户格式化输出数据，C++ 标准库专门提供了一个头文件，该头文件中包含有大量的格式控制符（严格意义上称为“流操纵算子”），使用更加方便。

C++ cout成员方法格式化输出

《C++输入流和输出流》一节中，已经针对 cout 讲解了一些常用成员方法的用法。除此之外，ostream 类中还包含一些可实现格式化输出的成员方法，这些成员方法都是从 ios 基类（以及 ios_base 类）中继承来的，cout（以及 cerr、clog）也能调用。

表 1 罗列了 ostream 类中可实现格式化输出的常用成员方法，以及它们各自的用法。

成员函数	说明
flags(fmtfl)	当前格式状态全部替换为 fmtfl。注意，fmtfl 可以表示一种格式，也可以表示多种格式。
precision(n)	设置输出浮点数的精度为 n。
width(w)	指定输出宽度为 w 个字符。
fill©	在指定输出宽度的情况下，输出的宽度不足时用字符 c 填充（默认情况是用空格填充）。
setf(fmtfl, mask)	在当前格式的基础上，追加 fmtfl 格式，并删除 mask 格式。其中，mask 参数可以省略。
unsetf(mask)	在当前格式的基础上，删除 mask 格式。

其中，对于表 1 中 flags() 函数的 fmtfl 参数、setf() 函数中的 fmtfl 参数和 mask 参数以及 unsetf() 函数 mask 参数，可以选择表 2 中列出的这些值。

标志	作用
ios::boolapha	把 true 和 false 输出为字符串
ios::left	输出数据在本域宽范围内向左对齐
ios::right	输出数据在本域宽范围内向右对齐
ios::internal	数值的符号位在域宽内左对齐，数值右对齐，中间由填充字符填充
ios::dec	设置整数的基数为 10
ios::oct	设置整数的基数为 8
ios::hex	设置整数的基数为 16
ios::showbase	强制输出整数的基数（八进制数以 0 开头，十六进制数以 0x 打头）
ios::showpoint	强制输出浮点数的小点和尾数 0
ios::uppercase	在以科学记数法格式 E 和以十六进制输出字母时以大写表示
ios::showpos	对正数显示“+”号
ios::scientific	浮点数以科学记数法格式输出
ios::fixed	浮点数以定点格式（小数形式）输出
ios::unitbuf	每次输出之后刷新所有的流

举个例子：

#include <iostream>
using namespace std;
int main()
{
    double a = 1.23;
    //设定后续输出的浮点数的精度为 4
    cout.precision(4);
    cout <<"precision: "<< a << endl;
    //设定后续以科学计数法的方式输出浮点数
    cout.setf(ios::scientific);
    cout <<"scientific："<< a << endl;
    return 0;
}

程序执行结果为：

precision: 1.23
scientific：1.2300e+00

注意，当 cout 采用此方式进行格式化输出时，其后不能立即输出数据，而只能像示例程序中那样，再用一个 cout 输出数据。

值得一提的是，当调用 unsetf() 或者 2 个参数的 setf() 函数时，为了提高编写代码的效率，可以给 mask 参数传递如下 3 个组合格式：

ios::adjustfield：等价于 ios::left | ios::right | ios::internal；
ios::basefield：等价于 ios::dec | ios::oct | ios::hex；
ios::floatfield：等价于 ios::scientific | ios::fixed。

举个例子：

#include <iostream>
using namespace std;
int main()
{
    double f = 123;
    //设定后续以科学计数法表示浮点数
    cout.setf(ios::scientific);
    cout << f << '\\n';
    //删除之前有关浮点表示的设定
    cout.unsetf(ios::floatfield);
    cout << f;
    return 0;
}

程序执行结果为：

1.230000e+02
123

使用流操纵算子格式化输出

表 3 罗列了头文件中定义的一些常用的格式控制符，它们都可用于格式化输出。

流操纵算子	作用
*dec	以十进制形式输出整数	常用
hex	以十六进制形式输出整数
oct	以八进制形式输出整数
fixed	以普通小数形式输出浮点数
scientific	以科学计数法形式输出浮点数
left	左对齐，即在宽度不足时将填充字符添加到右边
*right	右对齐，即在宽度不足时将填充字符添加到左边
setbase(b)	设置输出整数时的进制，b=8、10 或 16
setw(w)	指定输出宽度为 w 个字符，或输入字符串时读入 w 个字符。注意，该函数所起的作用是一次性的，即只影响下一次 cout 输出。
setfill©	在指定输出宽度的情况下，输出的宽度不足时用字符 c 填充（默认情况是用空格填充）
setprecision(n)	设置输出浮点数的精度为 n。在使用非 fixed 且非 scientific 方式输出的情况下，n 即为有效数字最多的位数，如果有效数字位数超过 n，则小数部分四舍五人，或自动变为科学计数法输出并保留一共 n 位有效数字。在使用 fixed 方式和 scientific 方式输出的情况下，n 是小数点后面应保留的位数。
setiosflags(mask)	在当前格式状态下，追加 mask 格式，mask 参数可选择表 2 中的所有值。
resetiosflags(mask)	在当前格式状态下，删除 mask 格式，mask 参数可选择表 2 中的所有值。
boolapha	把 true 和 false 输出为字符串	不常用
*noboolalpha	把 true 和 false 输出为 0、1
showbase	输出表示数值的进制的前缀
*noshowbase	不输出表示数值的进制.的前缀
showpoint	总是输出小数点
*noshowpoint	只有当小数部分存在时才显示小数点
showpos	在非负数值中显示 +
*noshowpos	在非负数值中不显示 +
uppercase	十六进制数中使用 A~E。若输出前缀，则前缀输出 0X，科学计数法中输出 E
*nouppercase	十六进制数中使用 a~e。若输出前缀，则前缀输出 0x，科学计数法中输出 e。
internal	数值的符号（正负号）在指定宽度内左对齐，数值右对齐，中间由填充字符填充。

注意：“流操纵算子”一栏带有星号 * 的格式控制符，默认情况下就会使用。例如在默认情况下，整数是用十进制形式输出的，等效于使用了 dec 格式控制符。

和 cout 成员方法的用法不同，下面程序演示了表 3 中这些格式控制符的用法：

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    //以十六进制输出整数
    cout << hex << 16 << endl;
    //删除之前设定的进制格式，以默认的 10 进制输出整数
    cout << resetiosflags(ios::basefield)<< 16 << endl;
    double a = 123;
    //以科学计数法的方式输出浮点数
    cout << scientific << a << endl;
    //删除之前设定的科学计数法的方法
    cout << resetiosflags(ios::scientific) << a << endl;
    return 0;
}

程序执行结果为：

10
16
1.230000e+02
123

注意，如果两个相互矛盾的标志同时被设置，如先设置 setiosflags(ios::fixed)，然后又设置 setiosflags(ios::scientific)，那么结果可能就是两个标志都不起作用。因此，在设置了某标志，又要设置其他与之矛盾的标志时，就应该用 resetiosflags 清除原先的标志。

C++怎样对输入输出重定向？（3种方法）

《C++输入流和输出流》一节提到，cout 和 cerr、clog 的一个区别是，cout 允许被重定向，而 cerr 和 clog 都不支持。值得一提的是，cin 也允许被重定向。

那么，什么是重定向呢？在默认情况下，cin 只能接收从键盘输入的数据，cout 也只能将数据输出到屏幕上。但通过重定向，cin 可以将指定文件作为输入源，即接收文件中早已准备好的数据，同样 cout 可以将原本要输出到屏幕上的数据转而写到指定文件中。

C++ 中，实现重定向的常用方式有 3 种，本节将一一做详细讲解。

C++ freopen()函数实现重定向

freopen() 定义在<stdio.h>头文件中，是 C 语言标准库中的函数，专门用于重定向输入流（包括 scanf()、gets() 等）和输出流（包括 printf()、puts() 等）。值得一提的是，该函数也可以对 C++ 中的 cin 和 cout 进行重定向。

举个例子：

#include <iostream>    //cin、cout
#include <string>      //string
#include <stdio.h>     //freopen
using namespace std;
int main()  
{
    string name, url;
    //将标准输入流重定向到 in.txt 文件
    freopen("in.txt", "r", stdin);
    cin >> name >> url;
    //将标准输出重定向到 out.txt文件
    freopen("out.txt", "w", stdout); 
    cout << name << "\\n" << url;
    return 0;
}

执行此程序之前，我们需要找到当前程序文件所在的目录，并手动创建一个 in.txt 文件，其包含的内容如下：

C++
http://c.biancheng.net/cplus/

创建好 in.txt 文件之后，可以执行此程序，其执行结果为：

<–控制台中，既不需要手动输入，也没有任何输出

与此同时，in.txt 文件所在目录下会自动生成一个 out.txt 文件，其包含的内容和 in.txt 文件相同：

C++
http://c.biancheng.net/cplus/

显然，通过 2 次调用 freopen() 函数，分别对输入流和输出流重定向，使得 cin 不再接收由键盘输入的数据，而是直接从 in.txt 文件中获取数据；同样，cout 也不再将数据输出到屏幕上，而是写入到 out.txt 文件中。

C++ rdbuf()函数实现重定向

rdbuf() 函数定义在<ios>头文件中，专门用于实现 C++ 输入输出流的重定向。

值得一提的是，ios 作为 istream 和 ostream 类的基类，rdbuf() 函数也被继承，因此 cin 和 cout 可以直接调用该函数实现重定向。

rdbuf() 函数的语法格式有 2 种，分别为：

streambuf * rdbuf() const;
streambuf * rdbuf(streambuf * sb);

streambuf 是 C++ 标准库中用于表示缓冲区的类，该类的指针对象用于代指某个具体的流缓冲区。

其中，第一种语法格式仅是返回一个指向当前流缓冲区的指针；第二种语法格式用于将 sb 指向的缓冲区设置为当前流的新缓冲区，并返回一个指向旧缓冲区的对象。

举个例子：

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    //打开 in.txt 文件，等待读取
    ifstream fin("in.txt");
    //打开 out.txt 文件，等待写入
    ofstream fout("out.txt");
    streambuf *oldcin;
    streambuf *oldcout;
    char a[100];
    //用 rdbuf() 重新定向，返回旧输入流缓冲区指针
    oldcin = cin.rdbuf(fin.rdbuf());
    //从input.txt文件读入
    cin >> a;
    //用 rdbuf() 重新定向，返回旧输出流缓冲区指针
    oldcout = cout.rdbuf(fout.rdbuf());
    //写入 out.txt
    cout << a << endl;
    //还原标准输入输出流
    cin.rdbuf(oldcin); // 恢复键盘输入
    cout.rdbuf(oldcout); //恢复屏幕输出
    //打开的文件，最终需要手动关闭
    fin.close();
    fout.close();
    return 0;
}

程序中涉及到的文件操作，后续章节会做详细讲解，读者只需领悟 rdbuf() 函数的用法即可。

仍以前面创建好的 in.txt 文件为例，执行此程序后，控制台不会输出任何数据，而是会在该项目的目录下生成一个 out.txt 文件，其中就存有该程序的执行结果：

C++
http://c.biancheng.net/cplus/

C++通过控制台实现重定向

以上 2 种方法，都是从代码层面实现输入输出流的重定向。除此之外，我们还可以通过控制台实现输入输出的重定向。

举个例子，假设有如下代码（文件名为 demo.cpp）：

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string name, url;
    cin >> name >> url;
    cout << name << '\\n' << url;
    return 0;
}

通过编译、链接后，会生成一个 demo.exe 可执行文件，该执行文件可以双击执行，也可以在控制台上执行。例如，打开控制台（Windows 系统下指的是 CMD命令行窗口，Linux 系统下指的是 Shell 终端），并输入如下指令：

C:\\Users\\mengma>D:\\demo.exe
C++ http://c.biancheng.net/cplus/
C++
http://c.biancheng.net/cplus/

可以看到，demo.ext 成功被执行，但程序中的 cin 和 cout 并没有被重定向，因此这里仍需要我们手动输入测试数据。

在此基础上，继续在控制台执行如下指令：

C:\\Users\\mengma>D:\\demo.exe <in.txt >out.txt

需要注意的是，执行此命令前，需保证 C:\\Users\\mengma 目录下有 in.txt 文件。

执行后会发现，控制台没有任何输出。这是因为，我们使用了"<in.txt"对程序中的 cin 输入流做了重定向，同时还用 ">out.txt"对程序中的 cout 输出流做了重定向。

如果此时读者进入 C:\\Users\\mengma 目录就会发现，当前目录生成了一个 out.txt 文件，其中就存储了 demo.ext 的执行结果。

在控制台中使用 > 或者 < 实现重定向的方式，DOS、windows、Linux 以及 UNIX 都能自动识别。

C++如何管理输出缓冲区？

每个输出流都管理一个缓冲区，用来保存程序读写的数据。例如，如果执行下而的代码：

cout << “http://c.biancheng.net/cplus/”;

文本串可能立即打印出来，但也有可能被操作系统保存在缓冲区中，随后再打印。

有了缓冲机制，操作系统就可以将程序的多个输出操作组合成单一的系统级写操作。由于设备的写操作可能很耗时，允许操作系统将多个输出操作组合为单一的设备写操作可以带来很大的性能提升。

导致缓冲刷新（数据真正写到输出设备或文件）的原因有很多：

程序正常结束，作为 main() 函数的 return 操作的一部分，缓冲刷新被执行。
缓冲区满时，需要刷新缓冲，而后新的数据才能继续写入缓冲区。
我们可以使用操纵符如 endl 来显式刷新缓冲区。
在每个输出操作之后，我们可以用操作符 unitbuf 设置流的内部状态，来清空缓冲区。默认情况下，对 cerr 是设置 unitbuf 的，因此写到 cerr 的内容都是立即刷新的。
一个输出流可能被关联到另一个流。在这种情况下，当读写被关联的流时，关联到的流的缓冲区会被刷新。例如，默认情况下，cin 和 cerr 都关联到 cout。因此，读 cin 或写 cerr 都会导致 cout 的缓冲区被刷新。

刷新输出缓冲区

我们已经使用过操作符 endl，它完成换行并刷新缓冲区的工作。IO 库中还有两个类似的操纵符：

flush 和 ends。flush 刷新缓冲区，但不输出任何额外的字符；
ends向缓冲区插入一个空字符，然后刷新缓冲区。

值得一提得是，cout 所属 ostream 类中还提供有 flush() 成员方法，它和 flush 操纵符的功能完全一样，仅在使用方法上（ cout.flush() ）有区别。

请看下面的例子：

cout << "hi!" << endl;  //输出hi和一个换行，然后刷新缓冲区
cout << "hi!" << flush;  //输出hi，然后刷新缓冲区，不附加任何额外字符
cout << "hi!" << ends;  //输出hi和一个空字符，然后刷新缓冲区

unitbuf 操作符

如果想在每次输出操作后都刷新缓冲区，我们可以使用 unitbuf 操作符，它告诉流在接下来的每次写操作之后都进行一次 flush 操作。而 nounitbuf 操作符则重置流，使其恢复使用正常的系统管理的缓冲区刷新机制：

cout << unitbuf;  //所有输出操作后都会立即刷新缓冲区
//任何输出都立即刷新，无缓冲
cout << nounitbuf;  //回到正常的缓冲方式

警告：如果程序崩溃，输出缓冲区不会被刷新

如果程序异常终止，输出缓冲区是不会被刷新的。当一个程序崩溃后，它所输出的数据很可能停留在输出缓冲区中等待打印。

当调试一个已经崩溃的程序时，需要确认那些你认为已经输出的数据确实已经刷新了。否则，可能将大量时间浪费在追踪代码为什么没有执行上，而实际上代码已经执行了，只是程序崩溃后缓冲区没有被刷新，输出数据被挂起没有打印而已。

关联输入和输出流

当一个输入流被关联到一个输出流时，任何试图从输入流读取数据的操作都会先刷新关联的输出流。标准库将 cout 和 cin 关联在一起，因此下面语句：

cin >> ival;

导致 cout 的缓冲区被刷新。

交互式系统通常应该关联输入流和输出流。这意味着所有输出，包括用户提示信息，都会在读操作之前被打印出来。

tie() 函数可以用来绑定输出流，它有两个重载的版本：

ostream* tie ( ) const; //返回指向绑定的输出流的指针。
ostream* tie ( ostream* os ); //将 os 指向的输出流绑定的该对象上，并返回上一个绑定的输出流指针。

第一个版本不带参数，返冋指向出流的指针。如果本对象当前关联到一个输出流，则返回的就是指向这个流的指针，如果对象未关联到流，则返回空指针。

tie() 的第二个版本接受一个指向 ostream 的指针，将自己关联到此 ostream，即，x.tie(&o) 将流 x 关联到输出流 o。

我们既可以将一个 istream 对象关联到另一个 ostream，也可以将一个 ostream 关联到另一个 ostream：

cin.tie(&cout);  //仅仅是用来展示，标准库已经将 cin 和 cout 关联在一起
//old_tie 指向当前关联到 cin 的流（如果有的话）
ostream *old_tie = cin.tie(nullptr);  // cin 不再与其他流关联
//将 cin 与 cerr 关联，这不是一个好主意，因为 cin 应该关联到 cout
cin.tie(&cerr);  //读取 cin 会刷新 cerr 而不是 cout
cin.tie(old_tie);  //重建 cin 和 cout 间的正常关联

在这段代码中，为了将一个给定的流关联到一个新的输出流，我们将新流的指针传递给了 tie()。为了彻底解开流的关联，我们传递了一个空指针。每个流同时最多关联到一个流，但多个流可以同时关联到同一个ostream。

cin.get()：C++读取单个字符

get() 是 istream 类的成员函数，它有多种重载形式（请猛击这里了解详情），不过本文只介绍最简单最常用的一种：

int get();

此函数从输入流中读入一个字符，返回值就是该字符的 ASCII 码。如果碰到输入的末尾，则返回值为 EOF。

EOF 是 End of File 的缩写。istream 类中从输入流（包括文件）中读取数据的成员函数，在把输入数据都读取完后再进行读取，就会返回 EOF。EOF 是在 iostream 类中定义的一个整型常量，值为 -1。

get() 函数不会跳过空格、制表符、回车等特殊字符，所有的字符都能被读入。例如下面的程序：

#include <iostream>
using namespace std;
int main()
{
    int c;
    while ((c = cin.get()) != EOF)
        cout.put(c);
    return 0;
}

程序运行情况如下：

http://c.biancheng.net/cplus/↙
http://c.biancheng.net/cplus/
C++ Tutorial↙
C++ Tutorial
^Z↙

↙表示回车键，^Z表示 Ctrl+Z 组合键。

程序中的变量 c 应为 int 类型，而不能是 char 类型。在输入流中碰到 ASCII 码等于 0xFF 的字符时，cin.get() 返回 0xFF，0xFF 赋值给 c，此时如果 c 是 char 类型的，那么其值就是 -1（因为符号位为 1 代表负数），即等于 EOF，于是程序就错误地认为输入已经结束。

而在 c 为 int 类型的情况下，将 0xFF 赋值给 c，c 的值是 255（因为符号位为 0，是正数），而非 -1，即除非读到输入末尾，c 的值都不可能是 -1。

要将文本文件 test.txt 中的全部内容原样显示出来，程序可以如下编写：

#include <iostream>
using namespace std;
int main()
{
    int c;
    freopen("test.txt", "r", stdin);  //将标准输入重定向为 test.txt
    while ((c = cin.get()) != EOF)
        cout.put(c);
    return 0;
}

cin.getline()：C++读入一行字符串（整行数据）

getline() 是 istream 类的成员函数，它有如下两个重载版本：

istream & getline(char* buf, int bufSize);
istream & getline(char* buf, int bufSize, char delim);

第一个版本从输入流中读取 bufSize-1 个字符到缓冲区 buf，或遇到\\n为止（哪个条件先满足就按哪个执行）。函数会自动在 buf 中读入数据的结尾添加\\0。

第二个版本和第一个版本的区别在于，第一个版本是读到\\n为止，第二个版本是读到 delim 字符为止。\\n或 delim 都不会被读入 buf，但会被从输入流中取走。

这两个函数的返回值就是函数所作用的对象的引用。如果输入流中\\n或 delim 之前的字符个数达到或超过 bufSize，就会导致读入出错，其结果是：虽然本次读入已经完成，但是之后的读入都会失败。

从输入流中读入一行，可以用第一个版本。用cin >> str这种写法是不行的，因为此种读法在碰到行中的空格或制表符时就会停止，因此就不能保证 str 中读入的是整行。

第一个版本的 getline 函数的用法示例如下：

#include <iostream>
using namespace std;
int main()
{
    char szBuf[20];
    int n = 120;
    if(!cin.getline(szBuf,6))  //如果输入流中一行字符超过5个，就会出错
        cout << "error" << endl;
    cout << szBuf << endl;
    cin >> n;
    cout << n  << endl;
    cin.clear(); //clear能够清除cin内部的错误标记，使之恢复正常
    cin >> n;
    cout << n << endl;
    return 0;
}

程序的运行过程如下：

ab cd↙
ab cd
33↙
33
44↙
44

在上面的输入情况下，程序是正常的。程序运行过程中还可能出现如下情况：

ab cd123456k↙
error
ab cd
120
123456

第 7 行，读入时因字符串超长导致出错，于是第 11 行并没有从输入流读入 n，n 维持了原来的值 120。

第 12 行，调用 istream 的成员函数 clear() 清除 cin 内部的错误标记，此后 cin 又能正常读入了。因此，123456 在第 13 行被读入 n。

可以用 getline() 函数的返回值（为 false 则输入结束）来判断输入是否结束。例如，要将文件 test.txt 中的全部内容（假设文件中一行最长有 10 000个字符）原样显示，程序可以如下编写：

#include <iostream>
using namespace std;
const int MAX_LINE_LEN = 10000;  //假设文件中一行最长 10000 个字符
int main()
{
    char szBuf[MAX_LINE_LEN + 10];
    freopen("test.txt", "r", stdin);  //将标准输入重定向为 test.txt
    while (cin.getline(szBuf, MAX_LINE_LEN + 5))
        cout << szBuf << endl;
    return 0;
}

程序每次读入文件中的一行到 szBuf 并输出。szBuf 中不会读入回车符，因此输出 szBuf 后要再输出 endl 以换行。

C++如何跳过（忽略）指定字符？

ignore() 是 istream 类的成员函数，它的原型是：

istream & ignore(int n =1, int delim = EOF);

此函数的作用是跳过输入流中的 n 个字符，或跳过 delim 及其之前的所有字符，哪个条件先满足就按哪个执行。两个参数都有默认值，因此 cin.ignore() 就等效于 cin.ignore(1, EOF)，即跳过一个字符。

该函数常用于跳过输入中的无用部分，以便提取有用的部分。例如，输入的电话号码形式是Tel:63652823，Tel:就是无用的内容。例如下面的程序：

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin.ignore(5, 'A');
    cin >> n;
    cout << n;
    return 0;
}

程序的运行过程可能如下：

abcde34↙
34

cin.ignore() 跳过了输入中的前 5 个字符，其余内容被当作整数输入 n 中。

该程序的运行过程也可能如下：

abA34↙
34

cin.ignore() 跳过了输入中的 ‘A’ 及其前面的字符，其余内容被当作整数输入 n 中。

C++怎样查看输入流中的下一个字符？

peek() 是 istream 类的成员函数，它的原型是：

int peek();

此函数返回输入流中的下一个字符，但是并不将该字符从输入流中取走——相当于只是看了一眼下一个字符，因此叫 peek。

cin.peek() 不会跳过输入流中的空格、回车符。在输入流已经结束的情况下，cin.peek() 返回 EOF。

在输入数据的格式不同，需要预先判断格式再决定如何输入时，peek() 就能起到作用。

例题：编写一个日期格式转换程序，输入若干个日期，每行一个，要求全部转换为“mm-dd-yyyy”格式输出。输入的日期格式可以是“2011.12.24”（中式格式），也可以是“Dec 24 2011”（西式格式）。要求该程序对于以下输入数据：

Dec 3 1990
2011.2.3
458.12.1
Nov 4 1998
Feb 12 2011

输出结果应为：

12-03-1990
02-03-2011
12-01-0458
11-04-1998
02-12-2011

输入数据中的 Ctrl+Z 略去不写，因为输入数据也可能来自于文件。

编写这个程序时，如果输入的是中式格式，就用 cin>>year（假设 year 是 int 类型变量）读取年份，然后再读取后面的内容；如果输入是西式格式，就用 cin>>sMonth（假设 sMonth 是 string 类型对象）读取月份，然后读取后面的内容。

可是，如果没有将数据从输入流中读取出来，就无法判断输入到底是哪种格式。即便用 cin.get() 读取一个字符后再作判断，也很不方便。例如，在输入为2011.12.24的情况下，读取第一个字符2后就知道是格式一，问题是输入流中的已经被读取了，剩下的表示年份的部分只有011，如何将这个011和前面读取的2奏成一个整数 2011，也是颇费周折的事情。使用 peek() 函数很容易解决这个问题。

示例程序如下：

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
string Months[12] = { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug", "Sep","Oct","Nov","Dec" };
int main()
{
    int c;
    while((c = cin.peek()) != EOF) { //取输入流中的第一个字符进行查看
         int year,month,day;
         if(c >= 'A' && c <= 'Z') { //美国日期格式
            string sMonth;
            cin >> sMonth >> day >> year;
            for(int i = 0;i < 12; ++i)  //查找月份
                   if(sMonth == Months[i]) {
                    month = i + 1;
                    break;
                }
        }
        else { //中国日期格式
            cin >> year ;
            cin.ignore() >> month ; //用ignore跳过 "2011.12.3"中的'.'
            cin.ignore() >> day;
        }
        cin.ignore();   //跳过行末 '\\n'
        cout<< setfill('0') << setw(2) << month ;//设置填充字符'\\0'，输出宽度2
        cout << "-" << setw(2) << day << "-" << setw(4) << year << endl;
    }
    return 0;
}

istream 还有一个成员函数 istream & putback(char c)，可以将一个字符插入输入流的最前面。对于上面的例题，也可以在用 get() 函数读取一个字符并判断是中式格式还是西式格式时，将刚刚读取的字符再用 putback() 成员函数放回流中，然后再根据判断结果进行不同方式的读入。

C++ cin是如何判断输入结束（读取结束）的？

cin 可以用来从键盘输入数据；将标准输入重定向为文件后，cin 也可以用来从文件中读入数据。在输入数据的多少不确定，且没有结束标志的情况下，该如何判断输入数据已经读完了呢？

从文件中读取数据很好办，到达文件末尾就读取结束了。从控制台读取数据怎么办呢？总不能把控制台关闭吧？这样程序也运行结束了！

其实，在控制台中输入特殊的控制字符就表示输入结束了：

在 Windows 系统中，通过键盘输入时，按 Ctrl+Z 组合键后再按回车键，就代表输入结束。
在 UNIX/Linux/Mac OS 系统中，Ctrl+D 代表输入结束。

不管是文件末尾，还是 Ctrl+Z 或者 Ctrl+D，它们都是结束标志；cin 在正常读取时返回 true，遇到结束标志时返回 false，我们可以根据 cin 的返回值来判断是否读取结束。

cin 判断控制台（键盘）读取结束

输入若干个正整数，输出其中的最大值，程序该如何编写？

#include <iostream>
using namespace std;
int main()
{
    int n;
    int maxN = 0;
    while (cin >> n){  //输入没有结束，cin 就返回 true，条件就为真
        if (maxN < n)
            maxN = n;
    }
    cout << maxN <<endl;
    return 0;
}

在 Windows 下运行该程序，先输入以下整数：

10
30
93
206
8

然后在按下 Ctrl+Z 组合键（可以在当前行，也可以在新的一行），接着按下回车键，输入就结束了，此时 cin 返回 false，循环结束，得到了最大值。

完整的输入输出结果如下所示：

10↙
30↙
93↙
206↙
8↙
^Z↙
206

↙表示回车键，^Z表示 Ctrl+Z 组合键。

cin 判断文件读取结束

如果将标准输入重定向为某个文件，如在程序开始添加freopen("test.txt", "r", stdin);语句，或者不添加上述语句，但是在 Windows 的“命令提示符”窗口中输入：

mycin < test.txt //假设编译生成的可执行文件的名字为 mycin.exe

则都能使得本程序不再从键盘输入数据，而是从 test.txt 文件输入数据（前提是 test.txt 文件和 mycin.exe 在同一个文件夹中）。在这种情况下，test.txt 文件中并不需要包含 Ctrl+Z，只要有用空格或回车隔开的若干个正整数即可。

cin 读到文件末尾时，cin>>n就会返回 false，从而导致程序结束。例如，假定 test.txt 文件中的内容如下所示：

112
23123
34 444 55
44

对于前面的代码，在“命令提示符”窗口中先 cd 到 mycin.exe 所在目录，然后输入mycin < test.txt，则程序的输出是：

23123

下面是笔者实操演示图：

答疑解惑

在《C++重载<<和>>》一节中我们提到过 istream 类将>>重载为成员函数，而且这些成员函数的返回值是 cin 的引用。准确地说，cin>>n的返回值的确是 istream & 类型的，而 while 语句中的条件表达式的返回值应该是 bool 类型、整数类型或其他和整数类型兼容的类型，istream & 显然和整数类型不兼容，为什么while(cin>>n)还能成立呢？

这是因为，istream 类对强制类型转换运算符 bool 进行了重载，这使得 cin 对象可以被自动转换成 bool 类型。所谓自动转换的过程，就是调用 cin 的 operator bool() 这个成员函数，而该成员函数可以返回某个标志值，该标志值在 cin 没有读到输入结尾时为 true，读到输入结尾后变为 false。对该标志值的设置，在 operator <<() 成员函数中进行。

如果 cin 在读取过程中发生了错误，cin>>n这样的表达式也会返回 false。例如下面的程序：

#include <iostream>
using namespace std;
int main()
{
    int n;
    while (cin >> n)
        cout << n << endl;
    return 0;
}

程序本该输入整数，如果输入了一个字母，则程序就会结束。因为，应该读入整数时却读入了字母也算读入出错。

C++处理输入输出错误

当处理输入输出时，我们必须预计到其中可能发生的错误并给出相应的处理措施。

当我们输入时，可能会由于人的失误（错误理解了指令、打字错误、允许自家的小猫在键盘上散步等）、文件格式不符、错误估计了情况等原因造成读取失败。
当我们输出时，如果输出设备不可用、队列满或者发生了故障等，都会导致写入失败。

发生输入输

以上是关于c++输入输出流的主要内容，如果未能解决你的问题，请参考以下文章

C/C++编程笔记：C++中的标准输入流 & 标准输出流

C++ I/O流 (输入与输出)