C++学习笔记——输入与输出

概念

C++输入输出包含以下三个方面的内容：

1. 对系统指定的标准设备的输入和输出。即从键盘输入数据，输出到显示器屏幕。这种输入输出称为标准的输入输出，简称标准I/O。
2. 以外存磁盘文件为对象进行输入和输出，即从磁盘文件输入数据，数据输出到磁盘文件。以外存文件为对象的输入输出称为文件的输入输出，简称文件I/O。
3. 对内存中指定的空间进行输入和输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。这种输入和输出称为字符串输入输出，简称串I/O。

与C++输入输出有关的类和对象

I/O类库中的常用流类

类名	作用	在哪个头文件中声明
ios	抽象基类	iostream
istream ostream iostream	通用输入流和其他输入流的基类 通用输出流和其他输出流的基类 通用输入输出流和其他输入输出流的基类	iostream iostream iostream
ifstream ofstream fstream	输入文件流类 输出文件流类 输入输出文件流类	fstream fstream fstream
istrstream ostrstream strstream	输入字符串流类 输出字符串流类 输入输出字符串流类	strstream strstream strstream

与iostream类库有关的头文件

iostream类库中不同的类的声明被放在不同的头文件中，用户在自己的程序中用#include命令包含了有关的头文件就相当于在本程序中声明了所需要用到的类。可以换 —种说法：头文件是程序与类库的接口，iostream类库的接口分别由不同的头文件来实现。常用的有

• iostream 包含了对输入输出流进行操作所需的基本信息。
• fstream 用于用户管理的文件的I/O操作。
• strstream 用于字符串流I/O。
• stdiostream 用于混合使用C和C + +的I/O机制时，例如想将C程序转变为C++程序。
• iomanip 在使用格式化I/O时应包含此头文件。

文件中定义的4种流对象

对象	含义	对应设备	对应的类	c语言中相应的标准文件
cin	标准输入流	键盘	istream_withassign	stdin
cout	标准输出流	屏幕	ostream_withassign	stderr
cerr	标准错误流	屏幕	ostream_withassign	stderr
clog	标准错误流	屏幕	ostream_withassign	stderr

在iostream头文件中重载运算符

“<<”和“>>”本来在C++中是被定义为左位移运算符和右位移运算符的，由于在iostream头文件中对它们进行了重载，使它们能用作标准类型数据的输入和输出运算符。所以，在用它们的程序中必须用#include命令把iostream包含到程序中。

    #include <iostream>

在istream和ostream类（这两个类都是在iostream中声明的）中分别有一组成员函数对位移运算符“<<”和“>>”进行重载，以便能用它输入或输出各种标准数据类型的数据。对于不同的标准数据类型要分别进行重载，如：

    ostream operator << (int );  //用于向输出流插入一个int数据
    ostream operator << (float );  //用于向输出流插入一个float数据
    ostream operator << (char);  //用于向输出流插入一个char数据
    ostream operator << (char * );  //用于向输出流插入一个字符串数据

等。如果在程序中有下面的表达式：

 cout<<"C++";

实际上相当于：

 cout.operator <<("C++")

标准输出流

cout流对象

1) cout不是C++预定义的关键字，它是ostream流类的对象，在iostream中定义。
2)用“cout<<”输出基本类型的数据时，可以不必考虑数据是什么类型，系统会判断数据的类型，并根据其类型选择调用与之匹配的运算符重载函数。
3) cout流在内存中对应开辟了一个缓冲区，用来存放流中的数据，当向cout流插 人一个endl时，不论缓冲区是否已满，都立即输出流中所有数据，然后插入一个换行符， 并刷新流（清空缓冲区）。
4) 在iostream中只对”<<”和”>>”运算符用于标准类型数据的输入输出进行了重载，但未对用户声明的类型数据的输入输出进行重载。

cerr流对象

cerr流对象是标准错误流，cerr流已被指定为与显示器关联。cerr的作用是向标准错误设备(standard error device)输出有关出错信息。cerr与标准输出流cout的作用和用法差不多。但有一点不同：cout流通常是传送到显示器输出，但也可以被重定向输出到磁盘文件，而cerr流中的信息只能在显示器输出。

clog流对象

clog流对象也是标准错误流，它是console log的缩写。它的作用和cerr相同，都是在终端显示器上显示出错信息。区别：cerr是不经过缓冲区，直接向显示器上输出有关信息，而clog中的信息存放在缓冲区中，缓冲区满后或遇endl时向显示器输出。

格式化输出

#include <iostream>
#include <iomanip>//不要忘记包含此头文件
using namespace std;
int main()
{
   int a;
   cout<<"input a:";
   cin>>a;
   cout<<"dec:"<<dec<<a<<endl;  //以十进制形式输出整数
   cout<<"hex:"<<hex<<a<<endl;  //以十六进制形式输出整数a
   cout<<"oct:"<<setbase(8)<<a<<endl;  //以八进制形式输出整数a
   char *pt="China";  //pt指向字符串"China"
   cout<<setw(10)<<pt<<endl;  //指定域宽为,输出字符串
   cout<<setfill('*')<<setw(10)<<pt<<endl;  //指定域宽,输出字符串,空白处以'*'填充
   double pi=22.0/7.0;  //计算pi值
   //按指数形式输出,8位小数
   cout<<setiosflags(ios::scientific)<<setprecision(8);
   cout<<"pi="<<pi<<endl;  //输出pi值
   cout<<"pi="<<setprecision(4)<<pi<<endl;  //改为位小数
   cout<<"pi="<<setiosflags(ios::fixed)<<pi<<endl;  //改为小数形式输出
   return 0;
}

用于控输出格式的流成员函数

流成员函数	与之作用相同的控制符	作用
precision(n)	setprecision(n)	设置实数的精度为n位
width(n)	setw(n)	设置字段宽度为n位
fill(c)	setfill(c)	设置填充字符c
setf()	setiosflags()	设置输出格式状态，括号中应给出格式状态，内容与控制符setiosflags括号中的内容相同，如表13.5所示
unsetf()	resetioflags()	终止已设置的输出格式状态，在括号中应指定内容

表13.5 设置格式状态的格式标志

格式标志	作用
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	每次输出之后刷新所有的流
ios::stdio	每次输出之后清除stdout, stderr

#include <iostream>
using namespace std;
int main( )
{
   int a=21
   cout.setf(ios::showbase);//显示基数符号(0x或)
   cout<<"dec:"<<a<<endl;         //默认以十进制形式输出a
   cout.unsetf(ios::dec);         //终止十进制的格式设置
   cout.setf(ios::hex);           //设置以十六进制输出的状态
   cout<<"hex:"<<a<<endl;         //以十六进制形式输出a
   cout.unsetf(ios::hex);         //终止十六进制的格式设置
   cout.setf(ios::oct);           //设置以八进制输出的状态
   cout<<"oct:"<<a<<endl;         //以八进制形式输出a
   cout.unseft(ios::oct);
   char *pt="China";              //pt指向字符串"China"
   cout.width(10);                //指定域宽为
   cout<<pt<<endl;                //输出字符串
   cout.width(10);                //指定域宽为
   cout.fill('*');                //指定空白处以'*'填充
   cout<<pt<<endl;                //输出字符串
   double pi=22.0/7.0;            //输出pi值
   cout.setf(ios::scientific);    //指定用科学记数法输出
   cout<<"pi=";                   //输出"pi="
   cout.width(14);                //指定域宽为
   cout<<pi<<endl;                //输出pi值
   cout.unsetf(ios::scientific); //终止科学记数法状态
   cout.setf(ios::fixed);        //指定用定点形式输出
   cout.width(12);               //指定域宽为
   cout.setf(ios::showpos);      //正数输出“+”号
   cout.setf(ios::internal);     //数符出现在左侧
   cout.precision(6);            //保留位小数
   cout<<pi<<endl;               //输出pi,注意数符“+”的位置
   return 0;
}

1) 成员函数width(n)和控制符setw(n)只对其后的第一个输出项有效。如：

    cout. width(6);
    cout <<20 <<3.14<<endl;

在输出第一个输出项20时，域宽为6，因此在20前面有4个空格，在输出3.14时，width (6)已不起作用
2) 在表13.5中的输出格式状态分为5组，每一组中同时只能选用一种（例如dec、hex和oct中只能选一，它们是互相排斥的）。在用成员函数setf和控制符setiosflags设置输出格式状态后，如果想改设置为同组的另一状态，应当调用成员函数unsetf（对应于成员函数self）或resetiosflags（对应于控制符setiosflags），先终止原来设置的状态。
3) 用setf 函数设置格式状态时，可以包含两个或多个格式标志，由于这些格式标志在ios类中被定义为枚举值，每一个格式标志以一个二进位代表，因此可以用位或运算符“|”组合多个格式标志。
4)对输出格式的控制，既可以用控制符，也可以用cout流的有关成员函数，二者的作用是相同的。

用C++流成员函数put输出单个字符

在程序中一般用cout和插入运算符“<<”实现输出，cout流在内存中有相应的缓冲区。有时用户还有特殊的输出要求，例如只输出一个字符。ostream类除了提供上面介绍过的用于格式控制的成员函数外，还提供了专用于输出单个字符的成员函数put。如：

    cout.put('a');

调用该函数的结果是在屏幕上显示一个字符a。put函数的参数可以是字符或字符的ASCII代码(也可以是一个整型表达式)。

cin输入流

通过测试cin的真值，判断流对象是否处于正常状态。

#include <iostream>
using namespace std;
int main( )
{
   float grade;
   cout<<"enter grade:";
   while(cin>>grade)//能从cin流读取数据
   {
      if(grade>=85) cout<<grade<<"GOOD!"<<endl;
      if(grade<60) cout<<grade<<"fail!"<<endl;
      cout<<"enter grade:";
   }
   cout<<"The end."<<endl;
   return 0;
}

get()函数读入一个字符

get()函数是cin输入流对象的成员函数，它有3种形式：无参数的，有一个参数的，有3个参数的。

1) 不带参数的get函数

用来从指定的输入流中提取一个字符（包括空白字符），函数的返回值就是读入的字符。 若遇到输入流中的文件结束符，则函数值返回文件结束标志EOF(End Of File)，一般以-1代表EOF，用-1而不用0或正值，是考虑到不与字符的ASCII代码混淆，但不同的C ++系统所用的EOF值有可能不同。

2) 有一个参数的get函数

调用形式为

    cin.get(ch)

其作用是从输入流中读取一个字符，赋给字符变量ch。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。

3) 有3个参数的get函数

其调用形式为

    cin.get(字符数组, 字符个数n, 终止字符)

或

    cin.get(字符指针, 字符个数n, 终止字符)

其作用是从输入流中读取n-1个字符，赋给指定的字符数组(或字符指针指向的数组)，如果在读取n-1个字符之前遇到指定的终止字符，则提前结束读取。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。

getline()函数读入一行字符

getline函数的作用是从输入流中读取一行字符,其用法与带3个参数的get函数类似。即

    cin.getline(字符数组(或字符指针), 字符个数n, 终止标志字符)

#include <iostream>
using namespace std;
int main( )
{
   char ch[20];
   cout<<"enter a sentence:"<<endl;
   cin>>ch;
   cout<<"The string read with cin is:"<<ch<<endl;
   cin.getline(ch,20,'/');  //读个字符或遇'/'结束
   cout<<"The second part is:"<<ch<<endl;
   cin.getline(ch,20);  //读个字符或遇'/n'结束
   cout<<"The third part is:"<<ch<<endl;
   return 0;
}

一些与输入有关的istream类成员函数

eof 函数

eof是end of file的缩写，表示“文件结束”。从输入流读取数据，如果到达文件末尾(遇文件结束符)，eof函数值为非零值(真)，否则为0(假)。

peek函数

peek是“观察”的意思，peek函数的作用是观测下一个字符。其调用形式为：

    c=cin.peek( );

函数的返回值是指针指向的当前字符，但它只是观测，指针仍停留在当前位置，并不后移。如果要访问的字符是文件结束符，则函数值是EOF(-1)。

putback函数

其调用形式为

 cin.putback(ch);

其作用是将前面用get或getline函数从输入流中读取的字符ch返回到输入流，插入到当前指针位置，以供后面读取。

ignore函数

其调用形式为

    cin.ignore(n, 终止字符)

函数作用是跳过输入流中n个字符，或在遇到指定的终止字符时提前结束(此时跳过包括终止字符在内的若干字符)。

文件流类与文件流对象

文件流是以外存文件为输入输出对象的数据流。输出文件流是从内存流向外存文件的数据，输入文件流是从外存文件流向内存的数据。每一个文件流都有一个内存缓冲区与之对应。

文件的打开与关闭

所谓打开(open)文件是一种形象的说法，如同打开房门就可以进入房间活动一样。 打开文件是指在文件读写之前做必要的准备工作，包括：

• 为文件流对象和指定的磁盘文件建立关联，以便使文件流流向指定的磁盘文件。
• 指定文件的工作方式，如，该文件是作为输入文件还是输出文件，是ASCII文件还是二进制文件等。

以上工作可以通过两种不同的方法实现。

1) 调用文件流的成员函数open。如

    ofstream outfile;  //定义ofstream类(输出文件流类)对象outfile
    outfile.open("f1.dat",ios::out);  //使文件流与f1.dat文件建立关联

2) 在定义文件流对象时指定参数
在声明文件流类时定义了带参数的构造函数，其中包含了打开磁盘文件的功能。因此，可以在定义文件流对象时指定参数，调用文件流类的构造函数来实现打开文件的功能。如

    ostream outfile("f1.dat",ios::out);

一般多用此形式，比较方便。作用与open函数相同。

文件输入输出方式设置值

方式	作用
ios::in	以输入方式打开文件
ios::out	以输出方式打开文件（这是默认方式），如果已有此名字的文件，则将其原有内容全部清除
ios::app	以输出方式打开文件，写入的数据添加在文件末尾
ios::ate	打开一个已有的文件，文件指针指向文件末尾
ios: :trunc	打开一个文件，如果文件已存在，则删除其中全部数据，如文件不存在，则建立新文件。如已指定了 ios::out 方式，而未指定ios: :app，ios::ate，ios: :in，则同时默认此方式
ios:: binary	以二进制方式打开一个文件，如不指定此方式则默认为ASCII方式
ios::nocreate	打开一个已有的文件，如文件不存在，则打开失败。nocrcate的意思是不建立新文件
ios:: noreplace	如果文件不存在则建立新文件，如果文件已存在则操作失败，replace 的意思是不更新原有文件
ios::in l ios::out	以输入和输出方式打开文件，文件可读可写
ios:: out l ios::binary	以二进制方式打开一个输出文件
ios::in l ios::binary	以二进制方式打开一个输入文件

在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close。如

 outfile.close( );  //将输出文件流所关联的磁盘文件关闭

所谓关闭，实际上是解除该磁盘文件与文件流的关联，原来设置的工作方式也失效，这样，就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联，通过文件流对新的文件进行输入或输出。如

    outfile.open("f2.dat",ios::app|ios::nocreate);

此时文件流outfile与f2.dat建立关联，并指定了f2.dat的工作方式。

对ASCII文件的读写操作

对ASCII文件的读写操作可以用以下两种方法：
1) 用流插入运算符“<<”和流提取运算符“>>”输入输出标准类型的数据。
2) 用文件流的put、get、geiline等成员函数进行字符的输入输出

#include <fstream>
using namespace std;
int main( )
{
   int a[10];
   ofstream outfile("f1.dat",ios::out);//定义文件流对象,打开磁盘文件"f1.dat"
   if(!outfile)                        //如果打开失败,outfile返回值
   {
      cerr<<"open error!"<<endl;
      exit(1);
   }
   cout<<"enter 10 integer numbers:"<<endl;
   for(int i=0;i<10;i++)
   {
      cin>>a[i];
      outfile<<a[i]<<" ";
   }            //向磁盘文件"f1.dat"输出数据
   outfile.close();                   //关闭磁盘文件"f1.dat"
   return 0;
}

对二进制文件的读写操作

对二进制文件的读写主要用istream类的成员函数read和write来实现。这两个成员函数的原型为

    istream& read(char *buffer,int len);
    ostream& write(const char * buffer,int len);

字符指针buffer指向内存中一段存储空间。len是读写的字节数。调用的方式为：

    a. write(p1,50);
    b. read(p2,30);

上面第一行中的a是输出文件流对象，write函数将字符指针p1所给出的地址开始的50个字节的内容不加转换地写到磁盘文件中。在第二行中，b是输入文件流对象，read 函数从b所关联的磁盘文件中，读入30个字节(或遇EOF结束），存放在字符指针p2所指的一段空间内。

写文件

#include <fstream>
using namespace std;
struct student
{
   char name[20];
   int num;
   int age;
   char sex;
};
int main( )
{
   student stud[3]={"Li",1001,18,'f',"Fun",1002,19,'m',"Wang",1004,17,'f'};
   ofstream outfile("stud.dat",ios::binary);
   if(!outfile)
   {
      cerr<<"open error!"<<endl;
      abort( );//退出程序
   }
   for(int i=0;i<3;i++)
      outfile.write((char*)&stud[i],sizeof(stud[i]));
   outfile.close( );
   return 0;
}

读文件

#include <fstream>
using namespace std;
struct student
{
   string name;
   int num;
   int age;
   char sex;
};
int main( )
{
   student stud[3];
   int i;
   ifstream infile("stud.dat",ios::binary);
   if(!infile)
   {
      cerr<<"open error!"<<endl;
      abort( );
   }
   for(i=0;i<3;i++)
   infile.read((char*)&stud[i],sizeof(stud[i]));
   infile.close( );
   for(i=0;i<3;i++)
   {
      cout<<"NO."<<i+1<<endl;
      cout<<"name:"<<stud[i].name<<endl;
      cout<<"num:"<<stud[i].num<<endl;;
      cout<<"age:"<<stud[i].age<<endl;
      cout<<"sex:"<<stud[i].sex<<endl<<endl;
   }
   return 0;
}

在磁盘文件中有一个文件指针，用来指明当前应进行读写的位置。在输入时每读入 一个宇节，指针就向后移动一个字节。在输出时每向文件输出一个字节，指针就向后移动 一个字节，随着输出文件中字节不断增加，指针不断后移。对于二进制文件，允许对指针进行控制，使它按用户的意图移动到所需的位置，以便在该位置上进行读写。文件流提供 一些有关文件指针的成员函数。

文件流与文件指针有关的成员函数

成员函数	作 用
gcount()	返回最后一次输入所读入的字节数
tellg()	返回输入文件指针的当前位置
seekg(文件中的位置）	将输入文件中指针移到指定的位置
seekg(位移量, 参照位置）	以参照位置为基础移动若干字节
tellp()	返回输出文件指针当前的位置
seekp(文件中的位置）	将输出文件中指针移到指定的位置
seekp(位移量, 参照位置）	以参照位置为基础移动若干字节

1) 这些函数名的第一个字母或最后一个字母不是g就是p。带 g的是用于输入的函数（g是get的第一个字母，以g作为输入的标识，容易理解和记忆）， 带p的是用于输出的函数（P是put的第一个字母，以P作为输出的标识）。

2) 函数参数中的“文件中的位置”和“位移量”已被指定为long型整数，以字节为单位。“参照位置”可以是下面三者之一：

 ios::beg  文件开头(beg是begin的缩写)，这是默认值。
    ios::cur  指针当前的位置(cur是current的缩写)。
    ios::end  文件末尾。

它们是在ios类中定义的枚举常量。举例如下：

    infile.seekg(100);  //输入文件中的指针向前移到字节位置
    infile.seekg(-50,ios::cur);  //输入文件中的指针从当前位置后移字节
    outfile.seekp(-75,ios::end);  //输出文件中的指针从文件尾后移字节

一般情况下读写是顺序进行的,即逐个字节进行读写。但是对于二进制数据文件来说,可以利用上面的成员函数移动指针,随机地访问文件中任一位置上的数据,还可以修改文件中的内容。

#include <fstream>
using namespace std;
struct student
{
   int num;
   char name[20];
   float score;
};
int main( )
{
   student stud[5]={1001,"Li",85,1002,"Fun",97.5,1004,"Wang",54,1006,"Tan",76.5,1010,"ling",96};
   fstream iofile("stud.dat",ios::in|ios::out|ios::binary);
   //用fstream类定义输入输出二进制文件流对象iofile
   if(!iofile)
   {
      cerr<<"open error!"<<endl;
      abort( );
   }
   for(int i=0;i<5;i++)  //向磁盘文件输出个学生的数据
      iofile.write((char *)&stud[i],sizeof(stud[i]));
   student stud1[5];  //用来存放从磁盘文件读入的数据
   for(int i=0;i<5;i=i+2)
   {
      iofile.seekg(i*sizeof(stud[i]),ios::beg);  //定位于第,2,4学生数据开头
      //先后读入个学生的数据,存放在stud1[0],stud[1]和stud[2]中
      iofile.read((char *)&stud1[i/2],sizeof(stud1[0]));
      //输出stud1[0],stud[1]和stud[2]各成员的值
      cout<<stud1[i/2].num<<" "<<stud1[i/2].name<<" "<<stud1[i/2].score<<endl;
   }
   cout<<endl;
   stud[2].num=1012;  //修改第个学生(序号为)的数据
   strcpy(stud[2].name,"Wu");
   stud[2].score=60;
   iofile.seekp(2*sizeof(stud[0]),ios::beg);  //定位于第个学生数据的开头
   iofile.write((char *)&stud[2],sizeof(stud[2]));  //更新第个学生数据
   iofile.seekg(0,ios::beg);  //重新定位于文件开头
   for(int i=0;i<5;i++)
   {
      iofile.read((char *)&stud[i],sizeof(stud[i]));  //读入个学生的数据
      cout<<stud[i].num<<" "<<stud[i].name<<" "<<stud[i].score<<endl;
   }
   iofile.close( );
   return 0;
}

请注意，不能用ifstream或ofstream类定义输入输出的二进制文件流对象，而应当用fstream类。

字符串流的读写

文件流是以外存文件为输入输出对象的数据流，字符串流不是以外存文件为输入输出的对象，而以内存中用户定义的字符数组(字符串)为输入输出的对象，即将数据输出到内存中的字符数组，或者从字符数组(字符串)将数据读入。字符串流也称为内存流。

文件流类有ifstream,ofstream和fstream,而字符串流类有istrstream,ostrstream和strstream。文件流类和字符串流类都是ostream,istream和iostream类的派生类,因此对它们的操作方法是基本相同的。向内存中的一个字符数组写数据就如同向文件写数据一样,但有3点不同：

1. 输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据。在严格的意义上说，这不属于输入输出，称为读写比较合适。
   因为输入输出一般指的是在计算机内存与计算机外的文件（外部设备也视为文件）之间 的数据传送。但由于C++的字符串流采用了C++的流输入输出机制，因此往往也用输入和输出来表述读写操作。
2. 字符串流对象关联的不是文件,而是内存中的一个字符数组,因此不需要打开和关闭文件。
3. 每个文件的最后都有一个文件结束符,表示文件的结束。而字符串流所关联的字符数组中没有相应的结束标志,用户要指定一个特殊字符作为结束符,在向字符数组写入全部数据后要写入此字符。

字符串流类没有open成员函数，因此要在建立字符串流对象时通过给定参数来确立字符串流与字符数组的关联。即通过调用构造函数来解决此问题。建立字符串流对象的方法与含义如下。

建立输出字符串流对象

ostrstream类提供的构造函数的原型为：

ostrstream::ostrstream(char *buffer,int n,int mode=ios::out);

buffer是指向字符数组首元素的指针，n为指定的流缓冲区的大小（一般选与字符数组的大小相同，也可以不同），第3个参数是可选的，默认为ios::out方式。可以用以下语句建立输出字符串流对象并与字符数组建立关联：

    ostrstream strout(ch1,20);

作用是建立输出字符串流对象strout，并使strout与字符数组ch1关联（通过字符串流将数据输出到字符数组ch1），流缓冲区大小为20。

建立输入字符串流对象

istrstream类提供了两个带参的构造函数，原型为：

    istrstream::istrstream(char *buffer);
    istrstream::istrstream(char *buffer,int n);

buffer是指向字符数组首元素的指针，用它来初始化流对象（使流对象与字符数组建立关联）。可以用以下语句建立输入字符串流对象：

    istrstream strin(ch2);

作用是建立输入字符串流对象strin，将字符数组ch2中的全部数据作为输入字符串流的内容。

    istrstream strin(ch2,20);

流缓冲区大小为20，因此只将字符数组ch2中的,20个字符作为输入字符串流的内容。

建立输入输出字符串流对象

strstream类提供的构造函数的原型为：

    strstream::strstream(char *buffer,int n,int mode);

可以用以下语句建立输入输出字符串流对象：

    strstream strio(ch3,sizeof(ch3),ios::in|ios::out);

作用是建立输入输出字符串流对象，以字符数组ch3为输入输出对象，流缓冲区大小与数组ch3相同。

以上个字符串流类是在头文件strstream中定义的，因此程序中在用到istrstream、ostrstream和strstream类时应包含头文件strstream（在GCC中，用头文件strstream）。

#include <strstream>
using namespace std;
struct student
{
   int num;
   char name[20];
   float score;
};
int main( )
{
   student stud[3]={1001,"Li",78,1002,"Wang",89.5,1004,"Fun",90};
   char c[50];  //用户定义的字符数组
   ostrstream strout(c,30);  //建立输出字符串流,与数组c建立关联,缓冲区长
   for(int i=0;i<3;i++)  //向字符数组c写个学生的数据
      strout<<stud[i].num<<stud[i].name<<stud[i].score;
   strout<<ends;  //ends是C++的I/O操作符,插入一个'\\0'
   cout<<"array c:"<<c<<endl;  //显示字符数组c中的字符
}

在一个字符数组c中存放了个整数,以空格相间隔,要求将它们放到整型数组中,再按大小排序,然后再存放回字符数组c中。

#include <strstream>
using namespace std;
int main( )
{
   char c[50]="12 34 65 -23 -32 33 61 99 321 32";
   int a[10],i,j,t;
   cout<<"array c:"<<c<<endl;  //显示字符数组中的字符串
   istrstream strin(c,sizeof(c));  //建立输入串流对象strin并与字符数组c关联
   for(i=0;i<10;i++)
      strin>>a[i];  //从字符数组c读入个整数赋给整型数组a
   cout<<"array a:";
   for(i=0;i<10;i++)
      cout<<a[i]<<" ";  //显示整型数组a各元素
   cout<<endl;
   for(i=0;i<9;i++)  //用起泡法对数组a排序
      for(j=0;j<9-i;j++)
         if(a[j]>a[j+1])
         {t=a[j];a[j]=a[j+1];a[j+1]=t;}
   ostrstream strout(c,sizeof(c));  //建立输出串流对象strout并与字符数组c关联
      for(i=0;i<10;i++)
         strout<<a[i]<<" ";  //将个整数存放在字符数组c
   strout<<ends;  //加入'\\0'
   cout<<"array c:"<<c<<endl;  //显示字符数组c
   return 0;
}

对字符串流的几点说明：
1) 用字符串流时不需要打开和关闭文件。

2) 通过字符串流从字符数组读数据就如同从键盘读数据一样，可以从字符数组读入字符数据，也可以读入整数、浮点数或其他类型数据。如果不用字符串流，只能从字符数组逐个访问字符，而不能按其他类型的数据形式读取数据。这是用字符串流访问字符数组的优点，使用方便灵活。

3) 先后建立两个字符串流strin和strout，与字符数组c关联。strin从字符数组c中获取数据，strout将数据传送给字符数组。分别对同一字符数组进行操作。甚至可以对字符数组交叉进行读写，输入字符串流和输出字符串流分别有流指针指示当前位 置，互不干扰。

4) 用输出字符串流向字符数组c写数据时，是从数组的首地址开始的，因此更新了 数组的内容。

5) 字符串流关联的字符数组并不一定是专为字符串流而定义的数组，它与一般的字符数组无异，可以对该数组进行其他各种操作。