POCO C++库学习和分析 -- 流（一）

我就是我 2022-03-20 05:42 233阅读 0赞

# POCO C++库学习和分析 -- 流 （一） #

流(Stream)是C++和C之间的一大区别。写C++的程序员都知道流的用法。在Poco库中，在标准流的基础上又扩充了一些流，分别是基于Base64和HexBinary的编解码流，使用zlib的数据压缩流，二进制的I/O流，文件流，以及一些其他的辅助流；另外Poco库还提供了一个扩展的结构，用于创建用户自定义流。  
  
          Poco库中所有的流类都与标准c++库中的流兼容。并且在Poco库中，大多数流都仅仅是个过滤器，这意味着它们不会直接从设备中读取或者写入数据，通常情况下它们会链接到另一个流上。下面我们分别对它们进行介绍。

## 1. 标准c++流介绍 ##

在介绍Poco的流之前，我觉得有必要了解C++中的输入输出流，不然就会觉得Poco中的流很难理解。在看完C++的流结构后，自然会对Poco库中的流内容豁然开朗。我也一样。  
          为了保证语言和平台无关，C++和C一样，不具备内部输入输出能力。语言的输入输出能力是和操作系统相关的，在最底层都是通过调用操作系统的I/O库实现。  
  
          在C++的iostream流库中，存在着两个基本部分。分别是：  
          1. 流：C++把输入和输出看作字节流。输入时，程序从输出流中抽取字节；输出时，程序将字节插入到输出流中。流充当了程序和流源或者流目标之间的桥梁。  
          2. 缓冲区：缓冲区是用作中介的内存块，它是将信息从设备传输到程序或者从程序传输到设备的临时存储工具，用以匹配程序和设备之间速度的差距。从设计上说，增加了缓冲区，使的C++的iostream结构更具有扩展性。  
  
          C++的 [输入输出类图][Link 1]：

![1366855314_4611.gif][]

下面对C++中各个流类的介绍主要来自于wiki以及网站 [cplusplus][]。

### 1.1 ios\_base ###

ios\_base类封装了C++标准中的流，并定义了在输入输出中不依赖于读写的数据类型的基本信息和行为，如格式化信息、异常状态、事件回调等。  
  
          在类std::ios\_base中，保存了下述关于流的信息：  
          格式控制信息的枚举类型fmtflags ，影响到如何解释输入串行的格式、如何生成输出串行的格式，例如整数是用16进制还是10进制表示，浮点数是科学计数法还是定点形式；  
          流的状态枚举类型iostate，如数据是否完整、是否到达流的末尾、是否读写失败等；  
          流的打开方式枚举类型openmode，如读取、写入、追加、创建时删除原内容、二进制打开、  
          流的定位位置枚举类型seekdir，如开始位置、当前位置、结尾位置等。  
          流的事件枚举类型event，如“擦除”事件erase\_event，改变locale设置事件imbue\_event，复制格式事件copyfmt\_event。  
          流的私有的其它额外保存的数据，为一个long型数组与一个指针数组。  
          一个成员类failure，用于作为C++标准中，流输入输出类库抛出的各种异常的基类。  
          一个成员类Init，用于封装cout、cin、wcout等8个静态对象的初始化函数。  
  
**          成员函数包括：  
  
          *格式化:***

1. 读取/设置流的格式

fmtflags flags() const;
    fmtflags flags (fmtflags fmtfl);

例子:

// modify flags
    #include <iostream>     // std::cout, std::ios
    
    int main () {
      std::cout.flags ( std::ios::right | std::ios::hex | std::ios::showbase );
      std::cout.width (10);
      std::cout << 100 << '\n';
      return 0;
    }

2. 设置流的格式，与原有格式合并

fmtflags setf (fmtflags fmtfl);
    fmtflags setf (fmtflags fmtfl, fmtflags mask);

例子:

// modifying flags with setf/unsetf
    #include <iostream>     // std::cout, std::ios
    
    int main () {
      std::cout.setf ( std::ios::hex, std::ios::basefield );  // set hex as the basefield
      std::cout.setf ( std::ios::showbase );                  // activate showbase
      std::cout << 100 << '\n';
      std::cout.unsetf ( std::ios::showbase );                // deactivate showbase
      std::cout << 100 << '\n';
      return 0;
    }

输出:  
         Output:  
         0x64  
         64  
  
  
          3. 根据参数mask，清除流的格式的某些位(bit)

void unsetf (fmtflags mask);

例子:

输出:  
         0x64  
         64  
  
  
          4. 读取/设置显示浮点数时的精度

streamsize precision() const;
    streamsize precision (streamsize prec);

例子:

// modify precision
    #include <iostream>     // std::cout, std::ios
    
    int main () {
      double f = 3.14159;
      std::cout.unsetf ( std::ios::floatfield );                // floatfield not set
      std::cout.precision(5);
      std::cout << f << '\n';
      std::cout.precision(10);
      std::cout << f << '\n';
      std::cout.setf( std::ios::fixed, std:: ios::floatfield ); // floatfield set to fixed
      std::cout << f << '\n';
      return 0;
    }

输出:  
         3.1416  
         3.14159  
         3.1415900000  
  
  
          5. 读取/设定流的输出数据的显示宽度

streamsize width() const;
    streamsize width (streamsize wide);

例子:

// field width
    #include <iostream>     // std::cout, std::left
    
    int main () {
      std::cout << 100 << '\n';
      std::cout.width(10);
      std::cout << 100 << '\n';
      std::cout.fill('x');
      std::cout.width(15);
      std::cout << std::left << 100 << '\n';
      return 0;
    }

输出:  
         100  
                100  
         100xxxxxxxxxxxx  
  
  
           ***语言环境:***  
          1. 给流设置本地语言环境

locale imbue (const locale& loc);

例子:

// imbue example
    #include <iostream>     // std::cout
    #include <locale>       // std::locale
    
    int main()
    {
      std::locale mylocale("");   // get global locale
      std::cout.imbue(mylocale);  // imbue global locale
      std::cout << 3.14159 << '\n';
      return 0;
    }

输出:

3,14159

2. 获取当前使用语言环境

locale getloc() const;

### 1.2 basic\_ios ###

basic\_ios定义出“与字符类型及其相应字符特性相关”的stream class的共同属性，其中包括清除流状态、设置流状态、拷贝流标志、返回或设置流缓冲区指针、设置本地化相关信息、返回或设置填充字符、字符转换，还包括了stream所用的缓冲器.  
          basic\_ios在其内部定义了一个指向streambuf的指针。

template <class Elem, class Traits>
    class basic_ios
         : public ios_base
    {
         //C++标准库封装了一个缓冲区类streambuf，以供输入输出流对象使用。
         //每个标准C++输出输出流对象都包含一个指向streambuf的指针，
         basic_streambuf<_Elem, _Traits>*_Mystrbuf;
    
    
         // ....
    }

** 成员函数包括:**  
  
         1. 状态标记函数:

bool good() const; //检查流状态位是否为good
    bool eof() const; //检查流状态位是否为eof，eofbit位被标志
    bool fail() const; //检查流状态位是否为fail，failbit或者badbit被标志
    bool bad() const; //检查流状态位是否为bad，badbit位被标志
    iostate rdstate() const; //返回流状态位

有两种方法可以获得输入/输出的状态信息。一种方法是通过调用rdstate()函数，它返回当前状态的错误标记。另一种方法则是使用good(), eof(),fail(), bad()函数来检测相应的输入/输出状态。  
          状态位和函数返回值关系如下表：

<table style="font-family:verdana,arial,helvetica,sans-serif; font-size:12px; color:rgb(0,0,0); border-collapse:collapse"> 
 <tbody> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"> <a href="http://www.cplusplus.com/ios_base::iostate" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">iostate</a>&nbsp;value<br> (member constant)</th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"> indicates</th> 
   <th colspan="5" style="background-color:rgb(240,240,240); border:1px solid black"> functions to check state flags</th> 
  </tr> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"><a href="http://www.cplusplus.com/ios::good" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">good()</a></th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"><a href="http://www.cplusplus.com/ios::eof" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">eof()</a></th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"><a href="http://www.cplusplus.com/ios::fail" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">fail()</a></th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"><a href="http://www.cplusplus.com/ios::bad" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">bad()</a></th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black"><a href="http://www.cplusplus.com/ios::rdstate" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">rdstate()</a></th> 
  </tr> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">goodbit</th> 
   <td style="border:1px solid black">No errors (zero value&nbsp;<a href="http://www.cplusplus.com/ios_base::iostate" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">iostate</a>)</td> 
   <td style="border:1px solid black; background-color:rgb(255,255,160)"> <code>true</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black">goodbit</td> 
  </tr> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">eofbit</th> 
   <td style="border:1px solid black">End-of-File reached on input operation</td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black; background-color:rgb(255,255,160)"> <code>true</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black">eofbit</td> 
  </tr> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">failbit</th> 
   <td style="border:1px solid black">Logical error on i/o operation</td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black; background-color:rgb(255,255,160)"> <code>true</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black">failbit</td> 
  </tr> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">badbit</th> 
   <td style="border:1px solid black">Read/writing error on i/o operation</td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black"><code>false</code></td> 
   <td style="border:1px solid black; background-color:rgb(255,255,160)"> <code>true</code></td> 
   <td style="border:1px solid black; background-color:rgb(255,255,160)"> <code>true</code></td> 
   <td style="border:1px solid black">badbit<br> <br> </td> 
  </tr> 
 </tbody> 
</table>

例子:

// error state flags
    #include <iostream>     // std::cout, std::ios
    #include <sstream>      // std::stringstream
    
    void print_state (const std::ios& stream) {
      std::cout << " good()=" << stream.good();
      std::cout << " eof()=" << stream.eof();
      std::cout << " fail()=" << stream.fail();
      std::cout << " bad()=" << stream.bad();
    }
    
    int main () {
      std::stringstream stream;
    
      stream.clear (stream.goodbit);
      std::cout << "goodbit:"; print_state(stream); std::cout << '\n';
    
      stream.clear (stream.eofbit);
      std::cout << " eofbit:"; print_state(stream); std::cout << '\n';
    
      stream.clear (stream.failbit);
      std::cout << "failbit:"; print_state(stream); std::cout << '\n';
    
      stream.clear (stream.badbit);
      std::cout << " badbit:"; print_state(stream); std::cout << '\n';
    
      return 0;
    }

输出:  
         goodbit: good()=1 eof()=0 fail()=0 bad()=0  
         eofbit: good()=0 eof()=1 fail()=0 bad()=0  
         failbit: good()=0 eof()=0 fail()=1 bad()=0  
         badbit: good()=1 eof()=0 fail()=1 bad()=1

2. oprator!()

bool operator!() const;

如果没有错误标记被设置(failbit或badbit),返回true，否则返回false

3. 设置/清除状态

void setstate (iostate state);
    void clear (iostate state = goodbit);

有两种方法可以设置输入/输出的状态信息。clear()函数可以使流状态将按照ios\_base::iostate所描述的样子进行设置。ios::failbit、ios::badbit、ios::eofbit、ios::goodbit均为常量，它们中的任何一个都代表了一种流状态，或可被称为“输入状态标记位常量”。它们不是failbit、badbit、eofbit、goodbit这四个标记位的存贮变量。标记为常量的状态如上表所述。  
  
         clear() 函数作用是：将流状态设置成括号内参数所代表的状态，强制覆盖掉流的原状态。

例子:

// clearing errors
    #include <iostream>     // std::cout
    #include <fstream>      // std::fstream
    
    int main () {
      char buffer [80];
      std::fstream myfile;
    
      myfile.open ("test.txt",std::fstream::in);
    
      myfile << "test";
      if (myfile.fail())
      {
        std::cout << "Error writing to test.txt\n";
        myfile.clear();
      }
    
      myfile.getline (buffer,80);
      std::cout << buffer << " successfully read from file.\n";
    
      return 0;
    }

setstate()函数的作用是：它并不强制覆盖流的原状态，而是将括号内参数所代表的状态叠加到原始状态上。它相当于：

void basic_ios::setstate (iostate state) {
      clear(rdstate()|state);
    }

4. 拷贝格式:

basic_ios& copyfmt (const basic_ios& rhs);

例子:

// copying formatting information
    #include <iostream>     // std::cout
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ofstream filestr;
      filestr.open ("test.txt");
    
      std::cout.fill ('*');
      std::cout.width (10);
      filestr.copyfmt (std::cout);
    
      std::cout << 40;
      filestr << 40;
    
      return 0;
    }

5. 设置或获取填充字符

char_type fill() const;
    char_type fill (char_type fillch);

例子:

// using the fill character
    #include <iostream>     // std::cout
    
    int main () {
      char prev;
    
      std::cout.width (10);
      std::cout << 40 << '\n';
    
      prev = std::cout.fill ('x');
      std::cout.width (10);
      std::cout << 40 << '\n';
    
      std::cout.fill(prev);
    
      return 0;
    }

输出:  
                 40  
         xxxxxxxx40

6. 返回和设置当前流的异常标志

iostate exceptions() const;
    void exceptions (iostate except);

例子:

// basic_ios::exceptions
    #include <iostream>     // std::cerr
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream file;
      file.exceptions ( std::ifstream::failbit | std::ifstream::badbit );
      try {
        file.open ("test.txt");
        while (!file.eof()) file.get();
      }
      catch (std::ifstream::failure e) {
        std::cerr << "Exception opening/reading file";
      }
    
      file.close();
    
      return 0;
    }

7. 返回和设置绑定的输出流(绑定流是一个输出流，输出流将在流的每一次I/O操作前先被输出)。“绑定”的效果也就相当于，每当被“绑定”的对象有输入或输出操作时，会先自动刷新“绑定”对象的缓冲区，以达到实时的效果。

basic_ostream<char_type,traits_type>* tie() const;
    basic_ostream<char_type,traits_type>* tie (basic_ostream<char_type,traits_type>* tiestr);

例子:

// redefine tied object
    #include <iostream>     // std::ostream, std::cout, std::cin
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ostream *prevstr;
      std::ofstream ofs;
      ofs.open ("test.txt");
    
      std::cout << "tie example:\n";
    
      *std::cin.tie() << "This is inserted into cout";
      prevstr = std::cin.tie (&ofs);
      *std::cin.tie() << "This is inserted into the file";
      std::cin.tie (prevstr);
    
      ofs.close();
    
      return 0;
    }

输出:  
         tie example:  
         This is inserted into cout  
  
  
         8. 返回或设置流缓冲区指针。用户可以通过调用rdbuf()成员函数获得该指针，从而直接访问底层streambuf对象。因此，可以直接对底层缓冲区进行数据读写，从而跳过上层的格式化输入输出操作。

basic_streambuf<char_type,traits_type>* rdbuf() const;
    basic_streambuf<char_type,traits_type>* rdbuf (basic_streambuf<char_type,traits_type>* sb);

例子:

// redirecting cout's output thrrough its stream buffer
    #include <iostream>     // std::streambuf, std::cout
    #include <fstream>      // std::ofstream
    
    int main () {
      std::streambuf *psbuf, *backup;
      std::ofstream filestr;
      filestr.open ("test.txt");
    
      backup = std::cout.rdbuf();     // back up cout's streambuf
    
      psbuf = filestr.rdbuf();        // get file's streambuf
      std::cout.rdbuf(psbuf);         // assign streambuf to cout
    
      std::cout << "This is written to the file";
    
      std::cout.rdbuf(backup);        // restore cout's original streambuf
    
      filestr.close();
    
      return 0;
    }

9. 字符转换  
         返回宽字符wc对应的字符dfault，在其内部使用了流对应的locale对象做转换

char narrow (char_type wc, char dfault) const;

返回c对应的宽字符

char_type widen (char c) const;

### 1.3  输入流（ istream） ###

istream是普通输入流类和用于其它输入流的基类。  
  
        ** 输入流的成员函数包括：**  
  
         1. 构造函数

explicit istream (streambuf* sb);

例子:

// istream constructor
    #include <iostream>     // std::ios, std::istream, std::cout
    #include <fstream>      // std::filebuf
    
    
    int main () {
      std::filebuf fb;
      if (fb.open ("test.txt",std::ios::in))
      {
        std::istream is(&fb);
        while (is)
          std::cout << char(is.get());
        fb.close();
      }
      return 0;
    }

2. 重载析取运算符

istream& operator>> (bool& val);
    istream& operator>> (short& val);
    istream& operator>> (unsigned short& val);
    istream& operator>> (int& val);
    istream& operator>> (unsigned int& val);
    istream& operator>> (long& val);
    istream& operator>> (unsigned long& val);
    istream& operator>> (float& val);
    istream& operator>> (double& val);
    istream& operator>> (long double& val);
    istream& operator>> (void*& val);
    stream buffers (2)	
    istream& operator>> (streambuf* sb );
    manipulators (3)	
    istream& operator>> (istream& (*pf)(istream&));
    istream& operator>> (ios& (*pf)(ios&));
    istream& operator>> (ios_base& (*pf)(ios_base&));

例子:

// example on extraction
    #include <iostream>     // std::cin, std::cout, std::hex
    
    int main () {
      int n;
    
      std::cout << "Enter a number: ";
      std::cin >> n;
      std::cout << "You have entered: " << n << '\n';
    
      std::cout << "Enter a hexadecimal number: ";
      std::cin >> std::hex >> n;         // manipulator
      std::cout << "Its decimal equivalent is: " << n << '\n';
    
      return 0;
    }

3. 无格式输入：

streamsize gcount() const;

获取最后一次执行析取操作所读取的字符串数目

例子:

// cin.gcount example
    #include <iostream>     // std::cin, std::cout
    
    int main () {
      char str[20];
    
      std::cout << "Please, enter a word: ";
      std::cin.getline(str,20);
      std::cout << std::cin.gcount() << " characters read: " << str << '\n';
    
      return 0;
    }

输出:  
         Please, enter a word: simplify  
         9 characteres read: simplify  
  
  
         4. 从流中以无格式输入方式析取字符串

int get()
    istream& get (char& c)
    istream& get (char* s, streamsize n)
    istream& get (char* s, streamsize n, char delim)
    istream& get (streambuf& sb)
    istream& get (streambuf& sb, char delim)

例子:

// istream::get example
    #include <iostream>     // std::cin, std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      char str[256];
    
      std::cout << "Enter the name of an existing text file: ";
      std::cin.get (str,256);    // get c-string
    
      std::ifstream is(str);     // open file
    
      while (is.good())          // loop while extraction from file is possible
      {
        char c = is.get();       // get character from file
        if (is.good())
          std::cout << c;
      }
    
      is.close();                // close file
    
      return 0;
    }

5. 从流中以无格式输入方式析取字符串(直至提取到指定的分隔字符，或已向流中写入最大长度的n个字符(包括终止空字符))，并存储内容进入c风格的字符串中。

istream& getline (char* s, streamsize n );
    istream& getline (char* s, streamsize n, char delim );

例子:

// istream::getline example
    #include <iostream>     // std::cin, std::cout
    
    int main () {
      char name[256], title[256];
    
      std::cout << "Please, enter your name: ";
      std::cin.getline (name,256);
    
      std::cout << "Please, enter your favourite movie: ";
      std::cin.getline (title,256);
    
      std::cout << name << "'s favourite movie is " << title;
    
      return 0;
    }

6. 从流中提取字符输入序列(直到n个字符被提取，或遇见一个指定的字符分隔符)，并丢弃。

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

例子:

// istream::ignore example
    #include <iostream>     // std::cin, std::cout
    
    int main () {
      char first, last;
    
      std::cout << "Please, enter your first name followed by your surname: ";
    
      first = std::cin.get();     // get one character
      std::cin.ignore(256,' ');   // ignore until space
    
      last = std::cin.get();      // get one character
    
      std::cout << "Your initials are " << first << last << '\n';
    
      return 0;
    }

7. 返回输入序列中的下一个字符，但不析取：字符将在下一次析取操作中从流中提取。

int peek();

例子:

// istream::peek example
    #include <iostream>     // std::cin, std::cout
    #include <string>       // std::string
    
    
    int main () {
    
      std::cout << "Please, enter a number or a word: ";
      char c = std::cin.peek();
    
      if ( (c >= '0') && (c <= '9') )
      {
        int n;
        std::cin >> n;
        std::cout << "You entered the number: " << n << '\n';
      }
      else
      {
        std::string str;
        std::getline (std::cin, str);
        std::cout << "You entered the word: " << str << '\n';
      }
    
      return 0;
    }

输出:  
         Please, enter a number or a word: foobar  
         You entered the word: foobar  
  
  
         8. 从流中析取n个字符，并把它们存储到s指向的字符数组

istream& read (char* s, streamsize n);

例子:

// read a file into memory
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream is ("test.txt", std::ifstream::binary);
      if (is) {
        // get length of file:
        is.seekg (0, is.end);
        int length = is.tellg();
        is.seekg (0, is.beg);
    
        char * buffer = new char [length];
    
        std::cout << "Reading " << length << " characters... ";
        // read data as a block:
        is.read (buffer,length);
    
        if (is)
          std::cout << "all characters read successfully.";
        else
          std::cout << "error: only " << is.gcount() << " could be read";
        is.close();
    
        // ...buffer contains the entire file...
    
        delete[] buffer;
      }
      return 0;
    }

输出:  
         Reading 640 characters... all characters read successfully.  
  
  
         9. 从流中析取n个字符，并把它们存储到s指向的字符数组。在内部关联的缓冲区(如果存在的话)用完时，操作返回，即使文件结束字符尚未达到。这个函数主要用于从某些类型的异步源中读取数据。由于析取操作会在内部缓冲区耗尽时终止，从而避免了潜在的延时。

streamsize readsome (char* s, streamsize n);

10. 把指定字符还给输入流，使得字符能够被重新析取

istream& putback (char c);

例子:

// istream::putback example
    #include <iostream>     // std::cin, std::cout
    #include <string>       // std::string
    
    int main () {
      std::cout << "Please, enter a number or a word: ";
      char c = std::cin.get();
    
      if ( (c >= '0') && (c <= '9') )
      {
        int n;
        std::cin.putback (c);
        std::cin >> n;
        std::cout << "You entered a number: " << n << '\n';
      }
      else
      {
        std::string str;
        std::cin.putback (c);
        getline (std::cin,str);
        std::cout << "You entered a word: " << str << '\n';
      }
      return 0;
    }

输出:  
         Please, enter a number or a word: pocket  
         You entered a word: pocket  
  
  
         11. 把上一个析取的字符还给输入流，使得字符能够被重新析取

istream& unget();

例子:

// istream::unget example
    #include <iostream>     // std::cin, std::cout
    #include <string>       // std::string
    
    int main () {
      std::cout << "Please, enter a number or a word: ";
      char c = std::cin.get();
    
      if ( (c >= '0') && (c <= '9') )
      {
        int n;
        std::cin.unget();
        std::cin >> n;
        std::cout << "You entered a number: " << n << '\n';
      }
      else
      {
        std::string str;
        std::cin.unget();
        getline (std::cin,str);
        std::cout << "You entered a word: " << str << '\n';
      }
      return 0;
    }

输出:  
         Please, enter a number or a word: 7791  
         You entered a number: 7791  
  
  
         12. 返回当前输入流字符的位置：

streampos tellg();

例子:

// read a file into memory
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream is ("test.txt", std::ifstream::binary);
      if (is) {
        // get length of file:
        is.seekg (0, is.end);
        int length = is.tellg();
        is.seekg (0, is.beg);
    
        // allocate memory:
        char * buffer = new char [length];
    
        // read data as a block:
        is.read (buffer,length);
    
        is.close();
    
        // print content:
        std::cout.write (buffer,length);
    
        delete[] buffer;
      }
    
      return 0;
    }

13. 设置下一个析取字符串在输入流中的位置

istream& seekg (streampos pos);
    istream& seekg (streamoff off, ios_base::seekdir way);

**         同步**  
         1. 同步流相关的缓冲区buf

int sync();

例子:

// syncing input stream
    #include <iostream>     // std::cin, std::cout
    
    int main () {
      char first, second;
    
      std::cout << "Please, enter a word: ";
      first = std::cin.get();
      std::cin.sync();
    
      std::cout << "Please, enter another word: ";
      second = std::cin.get();
    
      std::cout << "The first word began by " << first << '\n';
      std::cout << "The second word began by " << second << '\n';
    
      return 0;
    }

输出:  
         Please, enter a word: test  
         Please enter another word: text  
         The first word began by t  
         The second word began by t

### 1.4. 输出流（ostream） ###

ostream是普通输出流类和用于其它输出流类的基类。  
  
         1. 构造函数

explicit ostream (streambuf* sb);

例子:

// ostream constructor
    #include <iostream>     // std::cout, std::ostream, std::ios
    #include <fstream>      // std::filebuf
    
    int main () {
      std::filebuf fb;
      fb.open ("test.txt",std::ios::out);
      std::ostream os(&fb);
      os << "Test sentence\n";
      fb.close();
      return 0;
    }

2. 重载插入运算符

ostream& operator<< (bool val);
    ostream& operator<< (short val);
    ostream& operator<< (unsigned short val);
    ostream& operator<< (int val);
    ostream& operator<< (unsigned int val);
    ostream& operator<< (long val);
    ostream& operator<< (unsigned long val);
    ostream& operator<< (float val);
    ostream& operator<< (double val);
    ostream& operator<< (long double val);
    ostream& operator<< (void* val);
    ostream& operator<< (streambuf* sb );	
    ostream& operator<< (ostream& (*pf)(ostream&));
    ostream& operator<< (ios& (*pf)(ios&));
    ostream& operator<< (ios_base& (*pf)(ios_base&));

例子:

// example on insertion
    #include <iostream>     // std::cout, std::right, std::endl
    #include <iomanip>      // std::setw
    
    int main () {
      int val = 65;
    
      std::cout << std::right;       // right-adjusted (manipulator)
      std::cout << std::setw(10);    // set width (extended manipulator)
    
      std::cout << val << std::endl; // multiple insertions
    
      return 0;
    }

输出:  
        65  
  
  
          **无格式输出**  
         1. 把字符c插入流中

ostream& put (char c);

例子:

// typewriter
    #include <iostream>     // std::cin, std::cout
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ofstream outfile ("test.txt");
      char ch;
    
      std::cout << "Type some text (type a dot to finish):\n";
      do {
        ch = std::cin.get();
        outfile.put(ch);
      } while (ch!='.');
    
      return 0;
    }

2. 插入字符数组s的前n个字符进入流中

ostream& write (const char* s, streamsize n);

例子:

// Copy a file
    #include <fstream>      // std::ifstream, std::ofstream
    
    int main () {
      std::ifstream infile ("test.txt",std::ifstream::binary);
      std::ofstream outfile ("new.txt",std::ofstream::binary);
    
      // get size of file
      infile.seekg (0,infile.end);
      long size = infile.tellg();
      infile.seekg (0);
    
      // allocate memory for file content
      char* buffer = new char[size];
    
      // read content of infile
      infile.read (buffer,size);
    
      // write to outfile
      outfile.write (buffer,size);
    
      // release dynamically-allocated memory
      delete[] buffer;
    
      outfile.close();
      infile.close();
      return 0;
    }

3. 定位：  
         给出当前字符在输出流中的位置

streampos tellp();

例子:

// position in output stream
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ofstream outfile;
      outfile.open ("test.txt");
    
      outfile.write ("This is an apple",16);
      long pos = outfile.tellp();
      outfile.seekp (pos-7);
      outfile.write (" sam",4);
    
      outfile.close();
    
      return 0;
    }

输出:  
         This is a sample

4. 设置下一个在流中被插入字符的位置

ostream& seekp (streampos pos);	
    ostream& seekp (streamoff off, ios_base::seekdir way);

ios\_base::seekdir定义：

<table style="font-family:verdana,arial,helvetica,sans-serif; font-size:12px; color:rgb(0,0,0); border-collapse:collapse"> 
 <tbody> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">member constant</th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">seeking relative to</th> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">beg</td> 
   <td style="border:1px solid black">beginning of sequence.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">cur</td> 
   <td style="border:1px solid black">current position within sequence.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">end</td> 
   <td style="border:1px solid black">end of sequence.</td> 
  </tr> 
 </tbody> 
</table>

例子:

// position in output stream
    #include <fstream>      // std::ofstream
    
    
    int main () {
    
      std::ofstream outfile;
      outfile.open ("test.txt");
    
      outfile.write ("This is an apple",16);
      long pos = outfile.tellp();
      outfile.seekp (pos-7);
      outfile.write (" sam",4);
    
      outfile.close();
    
      return 0;
    }

** 同步：**  
         1. 同步关联的输出缓冲数据进入流

ostream& flush();

例子:

// Flushing files
    #include <fstream>      // std::ofstream
    
    int main () {
    
      std::ofstream outfile ("test.txt");
    
      for (int n=0; n<100; ++n)
      {
        outfile << n;
        outfile.flush();
      }
      outfile.close();
    
      return 0;
    }

### 1.5. 输入输出流（iostream） ###

iostream从ostream和istream继承，是普通输入输出流类和用于其它输入输出流的基类。iostream的接口包括了所有的ostream和istream接口。

### 1.6. 输出文件流类(ofstream) ###

1. 构造函数:

ofstream();
    explicit ofstream (const char* filename, ios_base::openmode mode = ios_base::out);

例子:

// ofstream constructor.
    #include <fstream>      // std::ofstream
    
    int main () {
    
      std::ofstream ofs ("test.txt", std::ofstream::out);
    
      ofs << "lorem ipsum";
    
      ofs.close();
    
      return 0;
    }

**成员函数:**  
         1. 打开文件

void open (const char* filename,  ios_base::openmode mode = ios_base::out);

mode

<table style="font-family:verdana,arial,helvetica,sans-serif; font-size:12px; color:rgb(0,0,0); border-collapse:collapse"> 
 <tbody> 
  <tr> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">member constant</th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">stands for</th> 
   <th style="background-color:rgb(240,240,240); border:1px solid black">access</th> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">in</td> 
   <td style="border:1px solid black"><strong>in</strong>put</td> 
   <td style="border:1px solid black">File open for reading: the&nbsp;<em><a href="http://www.cplusplus.com/fstream::rdbuf" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">internal stream buffer</a></em>&nbsp;supports input operations.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">out</td> 
   <td style="border:1px solid black"><strong>out</strong>put</td> 
   <td style="border:1px solid black">File open for writing: the&nbsp;<em><a href="http://www.cplusplus.com/fstream::rdbuf" style="text-decoration:none; color:rgb(0,0,112)" rel="nofollow">internal stream buffer</a></em>&nbsp;supports output operations.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">binary</td> 
   <td style="border:1px solid black"><strong>binary</strong></td> 
   <td style="border:1px solid black">Operations are performed in binary mode rather than text.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">ate</td> 
   <td style="border:1px solid black"><strong>at e</strong>nd</td> 
   <td style="border:1px solid black">The&nbsp;<em>output position</em>&nbsp;starts at the end of the file.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">app</td> 
   <td style="border:1px solid black"><strong>app</strong>end</td> 
   <td style="border:1px solid black">All output operations happen at the end of the file, appending to its existing contents.</td> 
  </tr> 
  <tr> 
   <td style="border:1px solid black">trunc</td> 
   <td style="border:1px solid black"><strong>trunc</strong>ate</td> 
   <td style="border:1px solid black">Any contents that existed in the file before it is open are discarded.</td> 
  </tr> 
 </tbody> 
</table>

插一句：app模式下，写指针每次都会在文件结尾，ate模式则只在打开时才将写指针置于文件末尾。ate赋予了程序员修改文件内容的能力。流seekp的能力是依赖于流内部缓冲区实现的。也就说如果不赋予流读文件的能力，没有读的缓冲区，流就无法seekp到文件的任意位置。所以想要定位到文件某一位置，对文件进行修改，要如下打开文件：

fstream(filename, ios::in|ios::out|ios::ate)。

例子:

// ofstream::open / ofstream::close
    #include <fstream>      // std::ofstream
    
    
    int main () {
    
      std::ofstream ofs;
      ofs.open ("test.txt", std::ofstream::out | std::ofstream::app);
    
      ofs << " more lorem ipsum";
    
      ofs.close();
    
      return 0;
    }

2. 确认文件是否打开

bool is_open();

在函数内部调用rdbuf()->is\_open()；  
  
         例子:

// ofstream::is_open
    #include <iostream>     // std::cout
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ofstream ofs;
      ofs.open ("test.txt");
      if (ofs.is_open())
      {
        ofs << "lorem ipsum";
        std::cout << "Output operation successfully performed\n";
        ofs.close();
      }
      else
      {
        std::cout << "Error opening file";
      }
      return 0;
    }

输出:  
         Output operation successfully performed  
  
  
         3. 关闭当前同流关联的文件

void close();

例子:

// ofstream::open / ofstream::close
    #include <fstream>      // std::ofstream
    
    int main () {
    
      std::ofstream ofs;
      ofs.open ("test.txt", std::ofstream::out | std::ofstream::app);
    
      ofs << " more lorem ipsum";
    
      ofs.close();
    
      return 0;
    }

4. 获取内部的文件流缓冲对象的指针

filebuf* rdbuf() const;

例子:

// copy a file using file stream buffers
    #include <fstream>      // std::filebuf, std::ifstream, std::ofstream
    #include <cstdio>       // EOF
    
    
    int main () {
      std::ifstream ifs ("test.txt");
      std::ofstream ofs ("copy.txt");
    
      std::filebuf* inbuf  = ifs.rdbuf();
      std::filebuf* outbuf = ofs.rdbuf();
    
      char c = inbuf->sbumpc();
      while (c != EOF)
      {
        outbuf->sputc (c);
        c = inbuf->sbumpc();
      }
    
      ofs.close();
      ifs.close();
    
      return 0;
    }

### 1.7. 输入文件流类(ifstream) ###

1. 构造函数:

ifstream();	
    explicit ifstream (const char* filename, ios_base::openmode mode = ios_base::in);

例子:

// ifstream constructor.
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
    
      std::ifstream ifs ("test.txt", std::ifstream::in);
    
      char c = ifs.get();
    
      while (ifs.good()) {
        std::cout << c;
        c = ifs.get();
      }
    
      ifs.close();
    
      return 0;
    }

**         成员函数:**  
  
         1. 打开文件

void open (const char* filename,  ios_base::openmode mode = ios_base::in);

例子:

// print the content of a text file.
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream ifs;
    
      ifs.open ("test.txt", std::ifstream::in);
    
      char c = ifs.get();
    
      while (ifs.good()) {
        std::cout << c;
        c = ifs.get();
      }
    
      ifs.close();
    
      return 0;
    }

2. 是否文件打开

bool is_open();

例子:

// ifstream::is_open
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream ifs ("test.txt");
    
      if (ifs.is_open()) {
        // print file:
        char c = ifs.get();
        while (ifs.good()) {
          std::cout << c;
          c = ifs.get();
        }
      }
      else {
        // show message:
        std::cout << "Error opening file";
      }
    
      return 0;
    }

3. 关闭流关联的文件

void close();

例子:

// print the content of a text file.
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream ifs;
    
      ifs.open ("test.txt");
    
      char c = ifs.get();
    
      while (ifs.good()) {
        std::cout << c;
        c = ifs.get();
      }
    
      ifs.close();
    
      return 0;
    }

4. 获取内部关联的文件缓冲区指针

filebuf* rdbuf() const;

例子:

// read file data using associated buffer's members
    #include <iostream>     // std::cout
    #include <fstream>      // std::filebuf, std::ifstream
    
    
    int main () {
      std::ifstream ifs ("test.txt", std::ifstream::binary);
    
      // get pointer to associated buffer object
      std::filebuf* pbuf = ifs.rdbuf();
    
      // get file size using buffer's members
      std::size_t size = pbuf->pubseekoff (0,ifs.end,ifs.in);
      pbuf->pubseekpos (0,ifs.in);
    
      // allocate memory to contain file data
      char* buffer=new char[size];
    
      // get file data
      pbuf->sgetn (buffer,size);
    
      ifs.close();
    
      // write content to stdout
      std::cout.write (buffer,size);
    
      delete[] buffer;
    
      return 0;
    }

### 1.8. 输入输出文件流(fstream) ###

fstream从ofstream和ifstream继承，其接口包括了所有的ofstream和ifstream接口。

### 1.9. 输出串流类(ostringstream) ###

1. 构造函数：

explicit ostringstream (ios_base::openmode which = ios_base::out);	
    explicit ostringstream (const string& str, ios_base::openmode which = ios_base::out);

例子:

// ostringstream constructor
    #include <iostream>     // std::cout, std::ios
    #include <sstream>      // std::ostringstream
    
    int main () {
      std::ostringstream foo;                            // out
      std::ostringstream bar (std::ostringstream::ate);  // out|ate
    
      foo.str("Test string");
      bar.str("Test string");
    
      foo << 101;
      bar << 101;
    
      std::cout << foo.str() << '\n';
      std::cout << bar.str() << '\n';
      return 0;
    }

输出:  
         101t string  
         Test string101  
  
  
**         成员函数：**  
  
         1.得到或获得字符串

string str() const;
    void str (const string& s);

例子:

// ostringstream::rdbuf
    #include <string>       // std::string
    #include <iostream>     // std::cout
    #include <sstream>      // std::ostringstream
    
    
    int main () {
      std::ostringstream oss;
      oss << "One hundred and one: " << 101;
      std::string s = oss.str();
      std::cout << s << '\n';
      return 0;
    }

输出:

One hundred and one: 101  
  
  
         2. 插入操作符

ostream& operator<< (bool val);
    ostream& operator<< (short val);
    ostream& operator<< (unsigned short val);
    ostream& operator<< (int val);
    ostream& operator<< (unsigned int val);
    ostream& operator<< (long val);
    ostream& operator<< (unsigned long val);
    ostream& operator<< (float val);
    ostream& operator<< (double val);
    ostream& operator<< (long double val);
    ostream& operator<< (void* val);
    ostream& operator<< (streambuf* sb );
    ostream& operator<< (ostream& (*pf)(ostream&));
    ostream& operator<< (ios& (*pf)(ios&));
    ostream& operator<< (ios_base& (*pf)(ios_base&));

例子:

输出:  
        65  
  
  
         3.插入字符c进入流

ostream& put (char c);

例子:

4.写字符串数组s的前n个字符进入流

ostream& write (const char* s, streamsize n);

例子:

5.获取当前字符在流中的位置

streampos tellp();

例子:

6.设置下一个插入字符在流中的位置

ostream& seekp (streampos pos);
    ostream& seekp (streamoff off, ios_base::seekdir way);

例子:

// position in output stream
    #include <fstream>      // std::ofstream
    
    int main () {
    
      std::ofstream outfile;
      outfile.open ("test.txt");
    
      outfile.write ("This is an apple",16);
      long pos = outfile.tellp();
      outfile.seekp (pos-7);
      outfile.write (" sam",4);
    
      outfile.close();
    
      return 0;
    }

输出:  
         This is a sample  
  
  
         7.同步关联的流缓冲数据进入流

ostream& flush();

例子:

### 1.10. 输入串流类(istringstream) ###

1. 构造函数:

explicit istringstream (ios_base::openmode which = ios_base::in);	
    explicit istringstream (const string& str, ios_base::openmode which = ios_base::in);

例子:

// istringstream constructors.
    #include <iostream>     // std::cout
    #include <sstream>      // std::istringstream
    #include <string>       // std::string
    
    int main () {
    
      std::string stringvalues = "125 320 512 750 333";
      std::istringstream iss (stringvalues);
    
      for (int n=0; n<5; n++)
      {
        int val;
        iss >> val;
        std::cout << val*2 << '\n';
      }
    
      return 0;
    }

输出:  
         250  
         640  
         1024  
         1500  
         666  
  
  
**         成员函数：**  
         1. 获取设置内容

string str() const;
    void str (const string& s);

例子:

// istringstream::str
    #include <string>       // std::string
    #include <iostream>     // std::cout
    #include <sstream>      // std::istringstream
    
    int main () {
      std::istringstream iss;
      std::string strvalues = "32 240 2 1450";
    
      iss.str (strvalues);
    
      for (int n=0; n<4; n++)
      {
        int val;
        iss >> val;
        std::cout << val << '\n';
      }
      std::cout << "Finished writing the numbers in: ";
      std::cout << iss.str() << '\n';
      return 0;
    }

输出:  
         32  
         240  
         2  
         1450  
         Finished writing the numbers in: 32 240 2 1450  
  
  
         2. 返回关联的内部缓冲区指针

stringbuf* rdbuf() const;

例子:

// istringstream::rdbuf
    #include <string>       // std::string
    #include <iostream>     // std::cout
    #include <sstream>      // std::istringstream, std::stringbuf
    
    int main () {
      std::istringstream iss;
      std::stringbuf *pbuf = iss.rdbuf();
    
      // using stringbuf directly:
      pbuf->str("Example string");
    
      int size = pbuf->in_avail();
    
      while (pbuf->in_avail()>0)
        std::cout << static_cast<char>(pbuf->sbumpc());
    
      return 0;
    }

输出:  
         Example string  
  
  
         3. 重载析取操作符

istream& operator>> (bool& val);
    istream& operator>> (short& val);
    istream& operator>> (unsigned short& val);
    istream& operator>> (int& val);
    istream& operator>> (unsigned int& val);
    istream& operator>> (long& val);
    istream& operator>> (unsigned long& val);
    istream& operator>> (float& val);
    istream& operator>> (double& val);
    istream& operator>> (long double& val);
    istream& operator>> (void*& val);
    istream& operator>> (streambuf* sb );
    istream& operator>> (istream& (*pf)(istream&));
    istream& operator>> (ios& (*pf)(ios&));
    istream& operator>> (ios_base& (*pf)(ios_base&));

例子:

4. 返回最后一次无格式输入操作所析取的字符数量

streamsize gcount() const;

例子:

输出:  
         Please, enter a word: simplify  
         9 characteres read: simplify  
  
  
         5. 以无格式输入方式从输入流中析取字符

int get();
    istream& get (char& c);
    istream& get (char* s, streamsize n);
    istream& get (char* s, streamsize n, char delim);	
    istream& get (streambuf& sb);
    istream& get (streambuf& sb, char delim);

例子:

6.以无格式输入方式从输入流中析取字符，并存储于c风格的字符串中。当析取字符是分割符或者已经析取了n个字符时，动作终止。默认情况下，分割符为"\\n".

istream& getline (char* s, streamsize n );
    istream& getline (char* s, streamsize n, char delim );

例子:

7. 从流中提取字符输入序列(直到n个字符提取，或遇见一个指定的字符分隔字)，并丢弃。

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

例子:

输出:  
         Please, enter your first name followed by your surname: John Smith  
         Your initials are JS  
  
  
         8. 返回输入序列中的下一个字符，但不析取：字符将在下一次析取操作中从流中提取。

int peek();

例子:

// istream::peek example
    #include <iostream>     // std::cin, std::cout
    #include <string>       // std::string
    
    int main () {
    
      std::cout << "Please, enter a number or a word: ";
      char c = std::cin.peek();
    
      if ( (c >= '0') && (c <= '9') )
      {
        int n;
        std::cin >> n;
        std::cout << "You entered the number: " << n << '\n';
      }
      else
      {
        std::string str;
        std::getline (std::cin, str);
        std::cout << "You entered the word: " << str << '\n';
      }
    
      return 0;
    }

输出:  
         Please, enter a number or a word: foobar  
         You entered the word: foobar  
  
  
         9. 从流中析取n个字符，并把它们存储入s指向的字符数组

istream& read (char* s, streamsize n);

例子:

// read a file into memory
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
    
      std::ifstream is ("test.txt", std::ifstream::binary);
      if (is) {
        // get length of file:
        is.seekg (0, is.end);
        int length = is.tellg();
        is.seekg (0, is.beg);
    
        char * buffer = new char [length];
    
        std::cout << "Reading " << length << " characters... ";
        // read data as a block:
        is.read (buffer,length);
    
        if (is)
          std::cout << "all characters read successfully.";
        else
          std::cout << "error: only " << is.gcount() << " could be read";
        is.close();
    
        // ...buffer contains the entire file...
    
        delete[] buffer;
      }
      return 0;
    }

输出:  
         Reading 640 characters... all characters read successfully.  
  
  
         10. 从流中析取n个字符，并把它们存储入s指向的字符数组。在内部关联的缓冲区(如果存在的话)用完时，操作返回，即使此时尚未达到文件结束字符。这个函数主要用于从某些类型的异步源中读取数据。由于析取操作会在内部缓冲区耗尽时终止，从而避免了潜在的延时。

streamsize readsome (char* s, streamsize n);

11. 把指定字符还给输入流，使得字符能够被重新析取

istream& putback (char c);

例子:

输出:  
         Please, enter a number or a word: pocket  
         You entered a word: pocket  
  
  
         12. 把上一次析取的字符还给输入流，使得字符能够被重新析取

istream& unget();

例子:

输出:  
         Please, enter a number or a word: 7791  
         You entered a number: 7791  
  
  
         13. 返回当前输入流字符的位置：

streampos tellg();

例子:

// read a file into memory
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream is ("test.txt", std::ifstream::binary);
      if (is) {
        // get length of file:
        is.seekg (0, is.end);
        int length = is.tellg();
        is.seekg (0, is.beg);
    
        // allocate memory:
        char * buffer = new char [length];
    
        // read data as a block:
        is.read (buffer,length);
    
        is.close();
    
        // print content:
        std::cout.write (buffer,length);
    
        delete[] buffer;
      }
    
      return 0;
    }

14. 设置下一个析取字符串在输入流中的位置

istream& seekg (streampos pos);
    istream& seekg (streamoff off, ios_base::seekdir way);

例子:

// read a file into memory
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream is ("test.txt", std::ifstream::binary);
      if (is) {
        // get length of file:
        is.seekg (0, is.end);
        int length = is.tellg();
        is.seekg (0, is.beg);
    
        // allocate memory:
        char * buffer = new char [length];
    
        // read data as a block:
        is.read (buffer,length);
    
        is.close();
    
        // print content:
        std::cout.write (buffer,length);
    
        delete[] buffer;
      }
    
      return 0;
    }

15. 同步流相关的缓冲区buf

int sync();

例子:

输出:  
         Please, enter a word: test  
         Please enter another word: text  
         The first word began by t  
         The second word began by t

### 1.11. 输入输出串流类（stringstream） ###

stringstream从iostream类继承，但是接口实现上同istringstream和ostringstream一致。

### 1.12. 输入输出文件流类（fstream） ###

在标准库中，fstream从iostream类继承，但是接口实现上同ifstream和ofstream。采用从ifstream和ofstream多继承的方案，个人觉得实现也可以。

### 1.13. 流缓冲区(streambuf) ###

streambuf类是所有流缓冲类的基类，内部处理窄字符(narror char)。  
         缓冲区类负责关联流类的读写操作。也就说，流把所有的读写操作都委托给了缓冲区类。缓冲区类是介于流和可控的输入输出序列之间的中介。所有的流对象，不管是有缓冲的还是没有缓冲的，都关联了一个流缓冲对象。当然在流缓冲对象内部可能存在或者不存在真实的缓冲。  
  
  
        ** 本地化：**  
         1. 关联locale对象到缓冲区

locale pubimbue (const locale& loc);

2. 获取当前使用的locale对象

locale getloc() const;

**         缓冲管理和位置信息**  
         1. 设置缓冲区字符数组

streambuf* pubsetbuf (char* s, streamsize n);

例子:

// set character buffer (pubsetbuf)
    #include <fstream>      // std::fstream
    
    int main () {
      char mybuffer [512];
      std::fstream filestr;
      filestr.rdbuf()->pubsetbuf(mybuffer,512);
    
      // operations with file stream here.
    
      return 0;
    }

2. 设置内部位置指针到指定位置(相对于way的偏移)

streampos pubseekoff (streamoff off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out);

例子:

// get file size using pubseekoff
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::fstream
    
    int main () {
      std::fstream filestr ("test.txt");
      if (filestr) {
        std::streambuf* pbuf = filestr.rdbuf();
        long size = pbuf->pubseekoff(0,filestr.end);
        std::cout << "The file size is " << size << " characters.\n";
        filestr.close();
      }
    
      return 0;
    }

3. 设置内部位置指针到指定位置(绝对位置)

streampos pubseekpos (streampos pos, ios_base::openmode which = ios_base::in | ios_base::out);

例子:

// changing position with pubseekpos
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::fstream
    
    int main () {
    
      std::fstream filestr ("test.txt");
      if (filestr) {
        std::streambuf* pbuf = filestr.rdbuf();
        long size = pbuf->pubseekoff(0,filestr.end);  // get size
        if (size>20) {
          char buffer[11];
          // change position to the 10th character
          pbuf->pubseekpos(10);
          // read 10 characters
          pbuf->sgetn (buffer,10);
          // append null character to string
          buffer[10]=0;
          std::cout << buffer << '\n';
        }
        filestr.close();
      }
      return 0;
    }

4. 同步流缓冲

int pubsync();

例子:

// pubsync member
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ofstream
    
    int main () {
      std::ofstream ostr ("test.txt");
      if (ostr) {
        std::streambuf * pbuf = ostr.rdbuf();
    
        pbuf->sputn ("First sentence\n",15);
        pbuf->pubsync();
        pbuf->sputn ("Second sentence\n",16);
    
        ostr.close();
      }
      return 0;
    }

**输入函数:**  
         1. 获取可读的字符数目

streamsize in_avail();

例子:

// get file size using pubseekoff
    #include <iostream>     // std::cout, std::streambuf, std::streamsize
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream ifs ("test.txt");
      if (ifs.good()) {
        std::streambuf* pbuf = ifs.rdbuf();
        char c; ifs >> c;
        std::streamsize size = pbuf->in_avail();
        std::cout << "first character in file: " << c << '\n';
        std::cout << size << " characters in buffer after it\n";
      }
      ifs.close();
    
      return 0;
    }

2. 前进输入流的当前位到下一字符，并返回下一个字符

int snextc();

例子:

// show file content - snextc() example
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ifstream
    #include <cstdio>       // EOF
    
    int main () {
      std::ifstream istr ("test.txt");
      if (istr) {
        std::streambuf * pbuf = istr.rdbuf();
        do {
          char ch = pbuf->sgetc();
          std::cout << ch;
        } while ( pbuf->snextc() != EOF );
        istr.close();
      }
      return 0;
    }

3. 返回输入流的当前位字符，并前进当前位到下一个字符

int sbumpc();

例子:

// show file content - sbumpc() example
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ifstream
    #include <cstdio>       // EOF
    
    
    int main () {
      std::ifstream istr ("test.txt");
      if (istr) {
        std::streambuf * pbuf = istr.rdbuf();
        while ( pbuf->sgetc() != EOF )
        {
          char ch = pbuf->sbumpc();
          std::cout << ch;
        }
        istr.close();
      }
      return 0;
    }

4. 返回输入流的当前位字符，不改变位置信息

int sgetc();

例子:

// show file content - sgetc() example
    #include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ifstream
    #include <cstdio>       // EOF
    
    
    int main () {
      std::ifstream istr ("test.txt");
      if (istr) {
        std::streambuf * pbuf = istr.rdbuf();
        do {
          char ch = pbuf->sgetc();
          std::cout << ch;
        } while ( pbuf->snextc() != EOF );
        istr.close();
      }
      return 0;
    }

5. 从指定的输入流中获取字符串，并把它们存储到s指向的字符串数组中。当n个字符已读或者输入流结束时，析取操作结束。

streamsize sgetn (char* s, streamsize n);

例子:

// read a file into buffer - sgetn() example
    #include <iostream>     // std::cout, std::streambuf, std::streamsize
    #include <fstream>      // std::ifstream
    
    int main () {
      char* contents;
      std::ifstream istr ("test.txt");
    
      if (istr) {
        std::streambuf * pbuf = istr.rdbuf();
        std::streamsize size = pbuf->pubseekoff(0,istr.end);
        pbuf->pubseekoff(0,istr.beg);       // rewind
        contents = new char [size];
        pbuf->sgetn (contents,size);
        istr.close();
        std::cout.write (contents,size);
      }
      return 0;
    }

6. 回退输入流的位置到指定字符c的上一个位置

int sputbackc (char c);

例子:

// sputbackc example
    #include <iostream>     // std::cin, std::cout, std::streambuf, std::streamsize
    #include <cstdio>       // EOF
    
    int main () {
      char ch;
      std::streambuf * pbuf = std::cin.rdbuf();
    
      std::cout << "Please, enter some letters and then a number: ";
      do {
        ch = pbuf->sbumpc();
    
        if ( (ch>='0') && (ch <='9') )
        {
          pbuf->sputbackc (ch);
          long n;
          std::cin >> n;
          std::cout << "You entered number " << n << '\n';
          break;
        }
      } while ( ch != EOF );
    
      return 0;
    }

7. 回退输入流的位置到上一个位置，和sputbackc类似，但是不含参数c

int sungetc();

例子:

**         输出函数:**  
         1. 存储字符于缓冲区当前位置并且移动输入指针位置

int sputc (char c);

例子:

// typewriter - sputc() example
    #include <iostream>     // std::cin, std::cout, std::streambuf
    #include <fstream>      // std::ofstream
    
    int main () {
      char ch;
      std::ofstream ostr ("test.txt");
      if (ostr) {
        std::cout << "Writing to file. Type a dot (.) to end.\n";
        std::streambuf * pbuf = ostr.rdbuf();
        do {
          ch = std::cin.get();
          pbuf->sputc(ch);
        } while (ch!='.');
        ostr.close();
      }
    
      return 0;
    }

2. 存储字符串序列于缓冲区中，直到存储数目到n或者输出序列结束

streamsize sputn (const char* s, streamsize n);

例子:

// sputn() example
    #include <iostream>     // std::streambuf
    #include <fstream>      // std::ofstream
    
    int main () {
      const char sentence[]= "Sample sentence";
    
      std::ofstream ostr ("test.txt");
      if (ostr) {
        std::streambuf * pbuf = ostr.rdbuf();
        pbuf->sputn (sentence,sizeof(sentence)-1);
        ostr.close();
      }
    
      return 0;
    }

### 1.14. 文件缓冲区流(filebuf) ###

**         成员函数:**  
         1. 打开文件，并关联其内容到指定的文件缓冲

filebuf* open (const char* filename,  ios_base::openmode mode);

例子:

// filebuf::open()
    #include <iostream>
    #include <fstream>
    
    int main () {
      std::ifstream is;
      std::filebuf * fb = is.rdbuf();
    
      fb->open ("test.txt",std::ios::out|std::ios::app);
    
      // >> appending operations here <<
    
      fb->close();
    
      return 0;
    }

2. 判断缓冲区是否已经关联文件

bool is_open() const;

例子:

// filebuf::is_open() example
    #include <iostream>
    #include <fstream>
    
    int main () {
      std::ifstream is;
      std::filebuf * fb = is.rdbuf();
      fb->open ("test.txt",std::ios::in);
    
      if ( fb->is_open() )
        std::cout << "the file is open.\n";
      else
        std::cout << "the file is not open.\n";
    
      fb->close();
    
      return 0;
    }

3. 关闭缓冲区关联的文件，并解除关联

filebuf* close();

例子:

// filebuf::close()
    #include <iostream>
    #include <fstream>
    
    int main () {
      std::ifstream is;
      std::filebuf * fb = is.rdbuf();
    
      fb->open ("test.txt",std::ios::in);
    
      // appending operations
    
      fb->close();
    
      return 0;
    }

### 1.15. 字符串的缓冲流类（stringbuf） ###

1. 获取设置字符串内容

string str() const;
    void str (const string& str);

例子:

// stringbuf example
    #include <string>       // std::string
    #include <iostream>     // std::cout, std::ostream, std::hex
    #include <sstream>      // std::stringbuf
    
    int main ()
    {
      std::stringbuf buffer;             // empty buffer
    
      std::ostream os (&buffer);      // associate stream buffer to stream
    
      // mixing output to buffer with inserting to associated stream:
      buffer.sputn ("255 in hexadecimal: ",20);
      os << std::hex << 255;
    
      std::cout << buffer.str();
    
      return 0;
    }

输出:

255 in hexadecimal: ff

### 1.16 标准库流总结 ###

上面啰里啰唆的讲了半天，总结如下：

1. ios\_base封装了流的格式

2. basic\_ios封装了流的状态信息。并定义了指向streambuf的指针，也就是说：所有的流都关联一个缓冲区。在流构造时，必须**显式的指定**一个缓冲区streambuf的指针。文件流和字符串流在构造函数里，并没有看到streambuf指针参数，并不代表不需要，在其内部封装。**所有流的输入输出操作都委托给了其内部的streambuf进行**。

3. istream定义了输入操作，其中最重要的是重载了">>"操作符。

4. ostream定义了输出操作，其中最重要的是重载了"<<"操作符。

5. iostream多重继承于istream和ostream，能够同时完成读写功能。

6. ofstream、ifstream、fstream完成文件读写工作，定义了文件open,close接口。

7. ostringstream、istringstream、stringstream完成了对字符串的读写工作，定义了str接口。重载了"<<"，">>"操作。

8. cerr(无缓冲标准错误)、clog(缓冲标准错误)、cout(缓冲标准输出)、cin(行缓冲)为标准库中预定义的stream对象。它们也关联有缓冲对象，其缓冲特性如下：

cerr(无缓冲标准错误)       -----      没有缓冲，发送给它的内容立即被输出

clog(缓冲标准错误)          -----      有缓冲，缓冲区满时输出

cout(缓冲标准输出)          -----      标准输出

cin(行缓冲)

附录:

在查阅C++流的相关资料时，发现有一篇文章很有意思，重点在底下的讨论。  文章链接为《[C++的流设计很糟糕][C]》。

[Link 1]: http://www.cplusplus.com/img/iostream.gif
[1366855314_4611.gif]: https://img-my.csdn.net/uploads/201304/25/1366855314_4611.gif
[cplusplus]: http://www.cplusplus.com/
[C]: http://www.cppblog.com/converse/archive/2010/07/06/119427.html
[http_blog.csdn.net_arau_sh_article_details_8698456]: http://blog.csdn.net/arau_sh/article/details/8698456