在C++语言中，为数据的输入和输出定义了一系列类库，主要包括：

ios,istream,ostream,iostream,ifstream,ofstream,fstream,istrstream,ostrstream,strstream等，其中ios为根基类，其余都是它的直接或间接派生类。其关系如图13-1所示。

图13-1 类库间的关系

ios为根基类，它直接派生四个类：输入流类istream、输出流类ostream、文件流基类fstreambase和串流基类strstreambase，输入文件流类同时继承了输入流类和文件流基类（当然对于根基类是间接继承），输出文件流类ofstream同时继承了输出流类和文件流基类，输入串流类istrstream同时继承了输入流类和串流基类，输出串流类ostrstream同时继承了输出流类和串流基类，输入输出流类iostream同时继承了输入流类和输出流类，输入输出文件流类fstream同时继承了输入输出流类和文件流基类，输入输出串流类strstream同时继承了输入输出流类和串流基类。

二、流类库的文件包含关系

各个流类在文件中的包含关系如表13-1。

表13-1 流类包含关系

当程序需要进行标准I/O操作的时候，必须包含头文件iostream。

当程序需要进行文件I/O操作的时候，必须包含头文件fstream。

当程序需要进行串I/O操作的时候，必须包含头文件sstream。

三、预定义流类对象

C++语言系统不仅定义了大量的输入输出流库供用户使用，还定义了四个常用的类对象，方便用户进行标准的I/O操作，如表13-2。

表13-2 C++常用的四个类对象

 【例13-1-1】 下边的代码用到标准I/O的实现。

源代码：

/* 例13-1-1，13-1-1.cpp */

#include<iostream>

using namespace std;

void main()

{

     int a, b, c;

     cout << "input a=";           //标准输出流（数据从输出流流向标准输出设备）

     cin >> a;                           //标准输入流（数据从标准输入设备流向输入流）

     cout << "input b=";    //标准输出流（数据从输出流流向标准输出设备）

     cin >> b;                           //标准输入流（数据从标准输入设备流向输入流）

     c = a + b;

     cout << "c=" << c << endl;       //标准输出流（数据从输出流流向标准输出设备）

}

 例文件I/O的实现

【例13-1-2】 标准I/O的实现。

源代码：

/* 例13-1-2，13-1-2.cpp */

#include<iostream>

#include<fstream>

#include<string>

using namespace std;

void main()

{

       char* s="This is a file.";

       ofstream my_ofstream("code.dat"); //定义一个输出文件流对象

       my_ofstream.write(s,strlen(s));        //调用该输出文件流对象的write()操作

       my_ofstream.close();                       //关闭输出文件流对象

       ifstream my_ifstream("code.dat");           //定义一个输入文件流对象

       char ch;

       while(my_ifstream.get(ch))               //循环把文件中所有字符读入输入文件流对象

       {

              cout<<ch;

       }

       my_ifstream.close();                        //关闭输入文件流对象

}

int a[1000];

int b[2000];

int c[3000];

...

merge(a, a + 1000, b, b + 2000, c);

如果用户想要合并一个vector和一个list（二者都是库中的模板类），并把结果放到一个新申请的未初始化的空间中，可以这样实现：

vector<Employee> a;

list<Employee> b;

...

Employee* c = allocate(a.size() + b.size(), (Employee*)0);

merge(a.begin(), a.end(), b.begin(), b.end(),

raw_storage_iterator<Employee*, Employee>(c));

其中 begin()和end()是容器的成员函数，它们返回正确的迭代器类型或者类似指针的对象，该迭代器或对象允许merge去做这项工作.raw_storage_iterator是一个适配器，它允许算法通过调用相应的拷贝构造函数把结果直接放到没有初始化的内存空间中。很多种情况下象通过常规数据结构一样迭带通过整个输入/输出流也是很有用的。例如，如果我们想要合并两个数据结构并把它们存储到一个文件中，那么能够避免为结果产生一个辅助数据结构，而直接把结果存到相应文件中去将是一种很好的方法。库同时提供了istream_iterator 和 ostream_iterator模板类，以便使库的多数算法能够和代表同类数据集合的I/O流一起工作。这里是一个从标准输入读取数字文件的程序，移走所有在命令参数不可见的输入，并把结果写到标准的输出中。

main(int argc, char** argv) {

if (argc != 2) throw(”usage: remove_if_divides integer\n”);

remove_copy_if(istream_iterator<int>(cin), istream_iterator<int>(),

ostream_iterator<int>(cout, ”\n”),

not1(bind2nd(modulus<int>(), atoi(argv[1]))));

}

所有的工作都是由remove_copy_if来做的，它一个个读整数直到输入迭代器和流的结束迭代器相等，后者是由无参的构造函数构造的。（一般，所有的算法以一种“从这到那”的方式工作，取两个分别表示输入开始和结束的迭代器做为参数）。然后remove_copy_if通过cout确定的迭代器传递检测到输出流。remove_copy_if使用的函数对象从modulus<int>构造而来，modulus<int>是二元谓词，输入参数I和j,返回I%j。由于remove_copy_if需要的是一元谓词，需要用bind2nd绑定modulus<int>的第二个参数，使之成为一元谓词。这里modulus<int>的第二个参数是命令行参数atoi(argv[1])。然后使用notl函数适配器得到这个一元谓词的否定。

一个更加现实的例子是一个过滤程序，该程序输入一个文件，然后随机的打乱它的行。

main(int argc, char**) {

if (argc != 1) throw(”usage: shuffle\n”);

vector<string> v;

copy(istream_iterator<string>(cin), istream_iterator<string>(),

inserter(v, v.end()));

random_shuffle(v.begin(), v.end());

copy(v.begin(), v.end(), ostream_iterator<string>(cout));

}

这个例子中，copy从标准输入移动行到一个vector中，但是由于这个vector没有提前分配空间，所以它用一个插入的迭代器一行行插入到vector中。（这项技术允许所有的复制函数在常规的覆盖模式和插入模式都能够工作）。然后random_shuffle随机打乱vector并再次调用copy把它复制到cout流中。

70个算法：
accumulate() 元素累加
adjacent_difference() 相邻元素的差额
adjacent_find() 搜寻相邻的重复元素
binary_search() 二元搜寻
copy() 复制
copy_backward() 逆向复制
count() 计数
count_if() 在特定条件下计数
equal() 判断相等与否
equal_range() 判断相等与否（传回一个上下限区间范围）
fill() 改填元素值
fill_n() 改填元素值，n 次
find() 搜寻
find_if() 在特定条件下搜寻
find_end() 搜寻某个子序列的最后一次出现地点
find_first_of() 搜寻某些元素的首次出现地点
for_each() 对范围内的每一个元素施行某动作
generate() 以指定动作的运算结果充填特定范围内的元素
generate_n() 以指定动作的运算结果充填 n 个元素内容
includes() 涵盖於
inner_product() 内积
inplace_merge() 合并并取代（覆写）
iter_swap() 元素互换
lexicographical_compare() 以字典排列方式做比较
lower_bound() 下限
max() 最大值
max_element() 最大值所在位置
min() 最小值
min_element() 最小值所在位置
merge() 合并两个序列
mismatch() 找出不吻合点
next_permutation() 获得下一个排列组合
泛型演算法（Generic Algorithms）与 Function Obje4 cts
nth_element() 重新安排序列中第n个元素的左右两端
partial_sort() 局部排序
partial_sort_copy() 局部排序并复制到它处
partial_sum() 局部总和
partition() 切割
prev_permutation() 获得前一个排列组合
random_shuffle() 随机重排
remove() 移除某种元素（但不删除）
remove_copy() 移除某种元素并将结果复制到另一个 container
remove_if() 有条件地移除某种元素
remove_copy_if() 有条件地移除某种元素并将结果复制到另一个 container
replace() 取代某种元素
replace_copy() 取代某种元素，并将结果复制到另一个 container
replace_if() 有条件地取代
replace_copy_if() 有条件地取代，并将结果复制到另一个 container
reverse() 颠倒元素次序
reverse_copy() 颠倒元素次序并将结果复制到另一个 container
rotate() 旋转
rotate_copy() 旋转，并将结果复制到另一个 container
search() 搜寻某个子序列
search_n() 搜寻「连续发生 n 次」的子序列
set_difference() 差集
set_intersection() 交集
set_symmetric_difference() 对称差集
set_union() 联集
sort() 排序
stable_partition() 切割并保持元素相对次序
stable_sort() 排序并保持等值元素的相对次序
swap() 置换（对调）
swap_range() 置换（指定范围）
transform() 以两个序列为基础，交互作用产生第三个序列
unique() 将重复的元素摺叠缩编，使成唯一
unique_copy() 将重复的元素摺叠缩编，使成唯一，并复制到他处
upper_bound() 上限
-- 以下是 heap 相关演算法 --
make_heap() 制造一个 heap
pop_heap() 从 heap 内取出一个元素
push_heap() 将一个元素推进 heap 内
sort_heap() 对 heap 排序

Answer：加号"＋"是一个运算符（operator），但是逗号"，"却有两种用法。第一种用法是作为分隔符（separator），比如我们最常见到的int i ,j ,k;但是还有一种用法，比较不常见，作为逗号运算符（comma operator）使用，也叫顺序运算符（sequence operator），最常见的使用是在for语句中，例如

for( int i = 0, j = i; i < max; ++i )…；

其实顾名思义，既然叫顺序运算符，那就是从左往右一个一个的求值，最后整个表达式的结果是最后一个求值的结果。例如：

int i,j,k;

i = 2, j = i+2, k = 3*j, i + j + k;

第二个语句从左往右一个一个的求值，i=2, j=i+2=4, k=3*j=12, i+j+k=18, 整个表达式结果是18，类型是i+j+k的类型int。

但是在所有的运算符优先级中，逗号运算符的优先级是最低的，而且标准也规定在逗号运算符中的表达式求值是动态确定的，既然是动态确定，那当然是不可以编译期间确定。因此，int a[2,3];中的逗号运算符表达式需要在运行时确定是3，但是数组的个数必须在编译期间确定，矛盾，编译不可能通过。标准中有规定，[const_expression],数组个数应该是一个const_expression,但是在这个const_expression中，comma operator是不可以使用的。【注2】

注2：请参考ANSI C++标准5.19

现在我们来做一个假设，如果逗号运算符表达式可以在编译时确定，也就是说int a[2,3];即为int a[3];那么一个有fortran背景的程序员第一次看到这个表达式，他肯定会认为是int a[2][3];以后的麻烦肯定就是如影随形。因此，标准禁止这种用法是非常明智的。不过，有一些编译器对C语言做了一些扩展，比如著名的GNU家族的gcc编译器，因此这个语句在gcc下是可以通过的，但是请记住，gcc是C语言编译器，g++才是C++语言编译器。下面的例子：

int a[2,3,4];

VC7.1不能通过；DEVC++4.9.7可以通过，表示int a[4];

2.如下的数组初始化，不能用static修饰数组，怎么改？

       class A

       {

        public:

            A():a（{1,2}） {}   //这样不行！

        private:

            const int a[2];

        };

Answer: 一个在类中，使用const修饰的，非静态数组不能被显示初始化。但是在这个问题中，数组a是个常量数组，因此它又不可能在构造函数体内被初始化。数组a不能被初始化的本质原因在于a是一系列连续对象的集合，它不能代表一个对象。例如：

int a[2],b[2]={1,2};

a=b;//不合法，a不能被赋值！

A只是一个数组名，它有两个意义，1.sizeof(a)中，a表示整个数组，sizeof(a)结果是整个数组所占内存的字节数；2.int j = a[1]中，a[1]是*(a+1)的另一种写法，a的值就是数组首元素的地址。上面的例子有两种解决办法。

(1).将a[2]转移到类层次中，即将const int a[2]改为static const int a[2],你可以认真的想一想，既然a[2]是const，那么每一个对象真的需要单独的一份a[2]吗？大部分时候答案应该是no。现在类定义如下：

       class A

       {

        public:

            A(){}

        private:

            static const int a[2];

        };

const int A::a[2] = {1,2};//在实现文件中。

(2)将数组改为指针，即const int a[2]改为const int* const a; 现在类定义如下：

                const int ca[2] = {1,2};//注意

       class A

       {

        public:

            A():a(ca){}

        private:

            const int* const a;

        };