C/C++编程：流缓冲类std::basic_streambuf

Bertha 。 2022-05-19 14:14 466阅读 0赞

>     template<
>         class CharT,
>         class Traits = std::char_traits<CharT>
>     > class basic_streambuf;
> 
> \\![20210302155633266.png][]
> 
> 该模板类的主要作用是**抽象原生设备**
> 
> 该模板被设计为所有*流缓冲区*类的基础虚拟类：
> 
>  *  IO流对象象 [std::basic\_istream][std_basic_istream] 及 [std::basic\_ostream][std_basic_ostream] ，还有所有派生自它们的对象（ [std::ofstream][std_ofstream] 、[std::stringstream][std_stringstream] 等），都完全以 `std::basic_streambuf` 实现。
>  *  在内部， basic\_streambufclass是精心设计的基类，旨在为所有派生类提供统一的公共接口：这些公共函数调用派生类可以重写以实现特定行为的虚拟受保护成员。这些被覆盖的虚拟功能可以通过一组受保护的函数访问内部的basic\_streambuf 类
> 
> 、
> 
> *流缓冲区*对象在内部至少保留：
> 
>  *  一种 locale 对象，用于与语言环境相关的操作。
>  *  一组内部指针，用于保留输入缓冲区： [eback][], [gptr][], [egptr][]。
>  *  一组内部指针，用于保留输出缓冲区： [pbase][], [pptr][], [epptr][]。

## 模板实例化 ##

*  [**streambuf**][streambuf]
 *  [**wstreambuf**][wstreambuf]

# 成员函数 #

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;本地环境</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pubimbue" rel="nofollow">pubimbue</a></p> </td> 
   <td>调用&nbsp;imbue()</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/getloc" rel="nofollow">getloc</a></p> </td> 
   <td>获得相关本地环境的副本</td> 
  </tr> 
 </tbody> 
</table>

### pubimbue ###

>     locale pubimbue (const locale& loc);
> 
> 功能：
> 
>  *  将loc 关联到*stream buffer*.
> 
> 返回值：
> 
>  *  返回*stream buffer*.在调用这个函数之前的locale

### getloc ###

>     locale getloc() const;
> 
> 功能：
> 
>  *  获取当前语言环境
>  *  如果成员函数 [pubimbue][] 已经被这个 *stream buffer*调用，那么返回设置的值，否则返回当前的全局语言环境
> 
> 返回值：
> 
>  *  返回locale对象当前与*流缓冲区*关联的对象。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2"> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;获取区</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/in_avail" rel="nofollow">in_avail</a></p> </td> 
   <td>获得获取区中立即可用的字符数</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/snextc" rel="nofollow">snextc</a></p> </td> 
   <td>令输入序列前进，读取一个字符而不再次前进</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sgetc" rel="nofollow">sgetc</a></p> </td> 
   <td>从输入序列读取一个字符，而不令序列前进</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sgetn" rel="nofollow">sgetn</a></p> </td> 
   <td>调用&nbsp;xsgetn()</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sbumpc" rel="nofollow">sbumpc</a></p> </td> 
   <td>从输入序列读取一个字符并令序列前进到下一个位置</td> 
  </tr> 
 </tbody> 
</table>

### in\_avail ###

>     streamsize in_avail（）;
> 
> 功能：
> 
>  *  获取可读取的字符数
>  *  此值取决于get指针（是否有直接可用的读取位置gptr）
> 
> 返回值：
> 
>  *  可读取的字符数
>  *  值-1表示没有其他字符可用

// 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;
    }
     编辑并运行

![20210302161929414.png][]

### snextc、sbumpc、sgetc、sgetn ###

>     int_type sbumpc（）;
> 
> 功能：
> 
>  *  `sbumpc：`获取当前字符并前进到下一个位置
> 
> 返回值：
> 
>  *  返回*受控输入序列*当前位置处的*字符*，并将位置指示器前进到下一个字符。
> 
> 请注意，尽管类似，但以下成员函数具有不同的行为：
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <th>成员功能</th> 
>    <th>描述</th> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#000000;"><code><a href="http://www.cplusplus.com/basic_streambuf::sgetc" rel="nofollow">sgetc()</a></code></td> 
>    <td style="border-color:#000000;">返回当前位置的字符。</td> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#000000;"><code>sbumpc()</code></td> 
>    <td style="border-color:#000000;">返回当前位置的字符，并将当前位置前进到下一个字符。</td> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#000000;"><code><a href="http://www.cplusplus.com/basic_streambuf::snextc" rel="nofollow">snextc()</a></code></td> 
>    <td style="border-color:#000000;">将当前位置前进到下一个字符并返回下一个字符。</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
>     int_type sgetc （）;
>     int_type snextc（）;
> 
> 功能：
> 
>  *  sgetc：从输入序列中读取一个字符
>  *  snextc：前进到下一个位置并读取一个字符
>  *  如果输入序列读取位置不可用，则返回[underflow（）][underflow]
> 
> 返回值：
> 
>  *  *get指针指向*的字符的值
> 
> >     streamsize sgetn（char_type * s，streamsize n）;
> > 
> > 功能：
> > 
> >  *  sgetn：获取字符序列
> > 
> > 返回值：
> > 
> >  *  成功读取的字符数。如果小于`count`输入序列，则结束。

#include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ifstream
    
    效果：逐个字符读取文件内容并输入
    int main () {
      std::ifstream istr ("test.txt");
      if (istr) {
        std::streambuf * pbuf = istr.rdbuf();
        while ( pbuf->sgetc() != std::streambuf::traits_type::eof() )
        {
          char ch = pbuf->sbumpc();
          std::cout << ch;
        }
        istr.close();
      }
      return 0;
    }

#include <iostream>
    #include <sstream>
     
    int main()
    {
        std::stringstream stream("Hello, world");
        std::cout << "sgetc() returned '" << (char)stream.rdbuf()->sgetc() << "'\n";
        std::cout << "peek() returned '" << (char)stream.peek() << "'\n";
        std::cout << "get() returned '" << (char)stream.get() << "'\n";
    }

![20210302171103963.png][]

#include <iostream>
    #include <sstream>
    
    int main()
    {
        std::stringstream stream("Hello, world");
        std::cout << "sgetc() returned '" << (char)stream.rdbuf()->snextc() << "'\n";
    }

###  ###

> ![20210302171832372.png][]

#include <iostream>     // std::cout, std::streambuf
    #include <fstream>      // std::ifstream
    
    // 本示例使用其流缓冲区将整个文件读入缓冲区，然后将其写入标准输出。
    int main () {
        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
    
            char *contents = new char[size];
    
            pbuf->sgetn(contents, size);
    
            istr.close();
    
            std::cout.write(contents, size);
        }
        return 0;
    }

> <table style="width:500px;"> 
>  <tbody> 
>   <tr> 
>    <td colspan="2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 放置区</td> 
>   </tr> 
>   <tr> 
>    <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sputc" rel="nofollow">sputc</a></p> </td> 
>    <td>写一个字符到放置区域，并令 next 指针前进</td> 
>   </tr> 
>   <tr> 
>    <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sputn" rel="nofollow">sputn</a></p> </td> 
>    <td>调用&nbsp;xsputn()</td> 
>   </tr> 
>  </tbody> 
> </table>

### std::basic\_streambuf::sputc、std::basic\_streambuf::sputn ###

>     int_type sputc( char_type ch );
> 
> 功能：
> 
>  *  sputc：将一个字符写入输出序列。
>  *  sputn：将n个字符写入到输出序列
>  *  如果输出序列写位置不可用（缓冲区已满），则调用overflow(ch)

#include <iostream> 
    #include <sstream> 
     
    int main （）
    { 
        std :: ostringstream s ; 
        s.rdbuf ()- > sputc ('a'); 
        std :: cout  << s.str() <<  ' \ n ' ; 
    }

![20210302173130967.png][]

#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;
    }

![20210302173207938.png][]

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;回放</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sputbackc" rel="nofollow">sputbackc</a></p> </td> 
   <td>在输入序列中放回一个字符</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sungetc" rel="nofollow">sungetc</a></p> </td> 
   <td>回移一位输出序列中的下一位置指针</td> 
  </tr> 
 </tbody> 
</table>

###  ###

### std::basic\_streambuf::sputbackc ###

>     int_type sputbackc（char_type c）;
> 
> 功能：将字符放回获取区域

#include <iostream>
    
    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';
            }
    
        } while ( ch != std::streambuf::traits_type::eof() );
    
        return 0;
    }

本示例从标准输入中一个接一个地获取字符。找到第一个数字后，反击被调用以将流中的位置恢复到该数字，以便使用提取运算符将其提取为数字的一部分`>>`。

![20210302172515866.png][]

### std::basic\_streambuf::sungetc ###

>     int_type sungetc（）;
> 
> 功能：
> 
>  *  如果在获取区域有一个后备仓位（gptr （） > eback （）），然后递减下一个指针（[gptr（）][gptr 1]）并返回它现在指向的字符。
>     
>     如果没有[备用][Link 1]位置，则在可能的情况下调用[pbackfail（）][Link 1]备份输入序列。
>     
>     I / O流功能[basic\_istream :: unget][basic_istream _ unget]是根据此功能实现的

#include <iostream>
    #include <sstream>
     
    int main()
    {
        std::stringstream s("abcdef"); // gptr() points to 'a'
        char c1 = s.get(); // c = 'a', gptr() now points to 'b' 
        char c2 = s.rdbuf()->sungetc(); // same as s.unget(): gptr() points to 'a' again 
        char c3 = s.get(); // c3 = 'a', gptr() now points to 'b'
        char c4 = s.get(); // c4 = 'b', gptr() now points to 'c'
        std::cout << c1 << c2 << c3 << c4 << '\n';
     
        s.rdbuf()->sungetc();  // back to 'b'
        s.rdbuf()->sungetc();  // back to 'a'
        int eof = s.rdbuf()->sungetc();  // nothing to unget: pbackfail() fails
        if (eof == EOF)
                std::cout << "Nothing to unget after 'a'\n";
    }

![20210302173444914.png][]

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 寻位</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pubsetbuf" rel="nofollow">setbuf</a>、<span style="color:#000000;">pubseekoff、</span>pubseekoff</p> </td> 
   <td>若容许则以用户定义数组替换缓冲区</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pubseekoff" rel="nofollow">seekoff</a></p> </td> 
   <td>用相对寻址重定位输入序列、输出序列或两者中的下一位置指针</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pubseekpos" rel="nofollow">seekpos</a></p> </td> 
   <td>用绝对寻址重定位输入序列、输出序列或两者中的下一位置指针</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pubsync" rel="nofollow">sync</a></p> </td> 
   <td>将缓冲与关联的字符序列同步</td> 
  </tr> 
 </tbody> 
</table>

### std::basic\_streambuf::pubsetbuf、std::basic\_streambuf::setbuf ###

>     basic_streambuf<CharT, Traits>* pubsetbuf( char_type* s, std::streamsize n )           (1)	
>     
>     protected:
>     virtual basic_streambuf<CharT, Traits>* setbuf( char_type* s, std::streamsize n )      (2)
> 
> 功能：设置相对于其他位置的输入或者输出序列的位置指示器
> 
> 1) 调用最终派生类上的 `setbuf(s, n)`
> 
> 2) 此函数的基类版本无效果。派生类可覆写此函数，以允许移除或替换受控制字符序列（缓冲区）为用户提供的数组，或为任何实现特定的目的。
> 
> **参数**
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td>s</td> 
>    <td>-</td> 
>    <td>指向用户提供的缓冲区中首个 CharT 的指针</td> 
>   </tr> 
>   <tr> 
>    <td>n</td> 
>    <td>-</td> 
>    <td>用户提供缓冲区中的 CharT 元素数</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> **返回值**
> 
> 1) `setbuf(s, n)` 的返回值
> 
> 2) this

#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,std::fstream::beg);
            std::cout << "The file size is " << size << " characters.\n";
            filestr.close();
        }
    
        return 0;
    }

![20210302164919656.png][]

#include <fstream>
    #include <iostream>
    #include <string>
    //为读取提供 10k 缓冲区。 Linux 上，可用 strace 工具观察实际读取的字节数
    int main()
    {
        int cnt = 0;
        std::ifstream file;
        char buf[1024*10 + 1];
    
        file.rdbuf()->pubsetbuf(buf, sizeof buf);
    
        file.open("/usr/share/dict/words");
    
        for (std::string line; getline(file, line);) {
            cnt++;
        }
    
        std::cout << cnt << '\n';
    }

## std::basic\_streambuf::pubseekoff、std::basic\_streambuf::seekoff ##

>     pos_type pubseekoff( off_type off, std::ios_base::seekdir dir,
>                          std::ios_base::openmode which = ios_base::in | ios_base::out );    (1)	
>     protected:
>     virtual pos_type seekoff( off_type off, std::ios_base::seekdir dir,
>                               std::ios_base::openmode which = ios_base::in | ios_base::out );  (2)
> 
> 相对某其他位置，设置输入/输出序列的位置指示器。
> 
> 1) 调用最终导出类的 `seekoff(off, dir, which)`
> 
> 2) 此函数的基类版本无效果。导出类可覆写此函数以允许位置指示器的相对寻位。
> 
> ### 参数 ###
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td>off</td> 
>    <td>要设置位置指示器到的相对位置。</td> 
>   </tr> 
>   <tr> 
>    <td>dir</td> 
>    <td> 
>     <table> 
>      <tbody> 
>       <tr> 
>        <td colspan="2">定义要应用相对偏移到的基位置。它能为下列常量之一：</td> 
>       </tr> 
>       <tr> 
>        <td>常量</td> 
>        <td>解释</td> 
>       </tr> 
>       <tr> 
>        <td><a href="https://zh.cppreference.com/w/cpp/io/ios_base/seekdir" rel="nofollow">beg</a></td> 
>        <td>流的开始</td> 
>       </tr> 
>       <tr> 
>        <td><a href="https://zh.cppreference.com/w/cpp/io/ios_base/seekdir" rel="nofollow">end</a></td> 
>        <td>流的结尾</td> 
>       </tr> 
>       <tr> 
>        <td><a href="https://zh.cppreference.com/w/cpp/io/ios_base/seekdir" rel="nofollow">cur</a></td> 
>        <td>流位置指示器的当前位置</td> 
>       </tr> 
>      </tbody> 
>     </table></td> 
>   </tr> 
>   <tr> 
>    <td>which</td> 
>    <td> 
>     <table> 
>      <tbody> 
>       <tr> 
>        <td colspan="2">定义输入和/或输出序列何者有影响。它能为下列常量之一或其组合：</td> 
>       </tr> 
>       <tr> 
>        <td>常量</td> 
>        <td>解释</td> 
>       </tr> 
>       <tr> 
>        <td><a href="https://zh.cppreference.com/w/cpp/io/ios_base/openmode" rel="nofollow">in</a></td> 
>        <td>影响输入序列</td> 
>       </tr> 
>       <tr> 
>        <td><a href="https://zh.cppreference.com/w/cpp/io/ios_base/openmode" rel="nofollow">out</a></td> 
>        <td>影响输出序列</td> 
>       </tr> 
>      </tbody> 
>     </table></td> 
>   </tr> 
>  </tbody> 
> </table>

#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;
    }

效果：读取并打印文件的第11至20个字符

###  ###

### std::basic\_streambuf::sync、std::basic\_streambuf::pubsync ###

>     int pubsync（）;       (1)
>      
>     protected:
>     virtual int sync();   (2)
> 
> 功能：
> 
> (1) 同步流缓冲区
> 
> (2) 此函数的基类版本无效果。导出类可覆写此函数以允许将底层设备与缓冲区同步。
> 
> 返回值：
> 
>  *  默认定义 [同步][Link 2] 在 [流缓冲][Link 3]总是返回零，表示成功。
>  *  派生类可以覆盖此默认行为，并最终返回`-1`以指示失败。

// 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;
    }

![20210302170347282.png][]

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 获取区</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/showmanyc" rel="nofollow">showmanyc</a></p> <p>[虚]</p> </td> 
   <td>若已知，则获得关联输入序列中可用于输入的字符数</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/underflow" rel="nofollow">underflow</a></p> <p>[虚]</p> </td> 
   <td>从关联输入序列读取字符到获取区</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/uflow" rel="nofollow">uflow</a></p> <p>[虚]</p> </td> 
   <td>从输入序列读取字符到获取区，并令下一位置指针前进</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sgetn" rel="nofollow">xsgetn</a></p> <p>[虚]</p> </td> 
   <td>从输入序列读取多个字符</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/gptr" rel="nofollow">eback、gptr、egptr</a></p> </td> 
   <td>返回指向获取区起始、当前字符和末尾的指针</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/gbump" rel="nofollow">gbump</a></p> </td> 
   <td>令输出序列中的下一位置指针前进</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/setg" rel="nofollow">setg</a></p> </td> 
   <td>重定位输出序列的起始、下一位置和终止指针</td> 
  </tr> 
 </tbody> 
</table>

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td colspan="2"> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 放置区</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/sputn" rel="nofollow">xsputn</a></p> <p>[虚]</p> </td> 
   <td>将多个字符写到输出序列</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/overflow" rel="nofollow">overflow</a></p> <p>[虚]</p> </td> 
   <td>从放置区写入字符到关联的输出序列</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pptr" rel="nofollow">pbase、pptre、pptr</a></p> </td> 
   <td>返回指向放置区的起始、当前字符和末尾的指针</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/pbump" rel="nofollow">pbump</a></p> </td> 
   <td>令输出序列中的下一位置指针前进</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/io/basic_streambuf/setp" rel="nofollow">setp</a></p> </td> 
   <td>重定位输出序列的起始、下一位置和终止指针</td> 
  </tr> 
 </tbody> 
</table>

### std::basic\_streambuf::pbump ###

#include <iostream>
    #include <string>
    #include <fstream>
     
    struct showput_streambuf : std::filebuf
    {
        using std::filebuf::pbump; // expose protected
        std::string showput() const {
            return std::string(pbase(), pptr());
        }
    };
     
    int main()
    {
        showput_streambuf mybuf;
        mybuf.open("test.txt", std::ios_base::out);
        std::ostream str(&mybuf);
        str << "This is a test" << std::flush << "1234";
        std::cout << "The put area contains: " << mybuf.showput() << '\n';
        mybuf.pbump(10);
        std::cout << "after pbump(10), it contains " << mybuf.showput() << '\n';
    }

### std::basic\_streambuf::setp ###

>     void setp (char_type* new_pbase, char_type* new_epptr);
> 
> 设置指针的值，这些指针定义*受控输出序列*的*缓冲*部分的边界([pbase][] and [epptr][]).
> 
> 该*置入指针*（[pptr][]）会自动设置为该序列的开头。  
> 这是一个受保护的成员，其他成员函数可以调用该成员来更改描述*受控输出序列*的缓冲部分的数组。

#include <iostream>
    #include <array>
    #include <streambuf>
    
    // Buffer for std::ostream implemented by std::array
    template<std::size_t SIZE, class CharT = char>
    class ArrayedStreamBuffer : public std::basic_streambuf<CharT>
    {
    public:
        using Base = std::basic_streambuf<CharT>;
        using char_type = typename Base::char_type;
    
        ArrayedStreamBuffer() : buffer_{} // value-initialize buffer_ to all zeroes
        {
            Base::setp(buffer_.begin(), buffer_.end()); // set std::basic_streambuf
            // put area pointers to work with 'buffer_'
        }
    
        void print_buffer()
        {
            for (const auto& i: buffer_) {
                if (i == 0) {
                    std::cout << "\\0";
                } else {
                    std::cout << i;
                }
                std::cout << ' ';
            }
            std::cout << '\n';
        }
    
    private:
        std::array<char_type, SIZE> buffer_;
    };
    
    int main () {
        ArrayedStreamBuffer<10> streambuf;
        std::ostream stream(&streambuf);
    
        stream << "hello";
        stream << ",";
    
        streambuf.print_buffer();
    
        return 0;
    }

![20210302174437896.png][]

[20210302155633266.png]: /images/20220519/1920bf0f8eeb4fe498f9d221bb55c362.png
[std_basic_istream]: https://zh.cppreference.com/w/cpp/io/basic_istream
[std_basic_ostream]: https://zh.cppreference.com/w/cpp/io/basic_ostream
[std_ofstream]: https://zh.cppreference.com/w/cpp/io/basic_ofstream
[std_stringstream]: https://zh.cppreference.com/w/cpp/io/basic_stringstream
[eback]: http://www.cplusplus.com/basic_streambuf::eback
[gptr]: http://www.cplusplus.com/basic_streambuf::gptr
[egptr]: http://www.cplusplus.com/basic_streambuf::egptr
[pbase]: http://www.cplusplus.com/basic_streambuf::pbase
[pptr]: http://www.cplusplus.com/basic_streambuf::pptr
[epptr]: http://www.cplusplus.com/basic_streambuf::epptr
[streambuf]: http://www.cplusplus.com/reference/streambuf/streambuf/
[wstreambuf]: http://www.cplusplus.com/reference/streambuf/wstreambuf/
[pubimbue]: http://www.cplusplus.com/streambuf::pubimbue
[20210302161929414.png]: /images/20220519/040cbec9e3c149cdb3df48757e7df1bf.png
[underflow]: https://en.cppreference.com/w/cpp/io/basic_streambuf/underflow
[20210302171103963.png]: /images/20220519/998d2b5269dd4f81a29ca97b7a6f9c9c.png
[20210302171832372.png]: /images/20220519/2d98d11c49894e8f8e4294d6e1f5a71e.png
[20210302173130967.png]: /images/20220519/df605d3d011c4cbeb656921dcc083af8.png
[20210302173207938.png]: /images/20220519/4f46281a10c0406cad5ff674a7e8f741.png
[20210302172515866.png]: /images/20220519/c4e0323447e243e3bc32a1448b17d127.png
[gptr 1]: https://en.cppreference.com/w/cpp/io/basic_streambuf/gptr
[Link 1]: https://en.cppreference.com/w/cpp/io/basic_streambuf/pbackfail
[basic_istream _ unget]: https://en.cppreference.com/w/cpp/io/basic_istream/unget
[20210302173444914.png]: /images/20220519/73182dfbf4ef47dc8c3c0dddcc2d8035.png
[20210302164919656.png]: /images/20220519/4af78abe65e949ef88d5533f3ef02591.png
[Link 2]: http://www.cplusplus.com/basic_streambuf::sync
[Link 3]: http://www.cplusplus.com/streambuf
[20210302170347282.png]: /images/20220519/94d32e172d0a41658f99bf7bf2d1bf58.png
[20210302174437896.png]: /images/20220519/f80674e9cc014f31b0617be9c56810a8.png