The following  protected members are available for output
operations. Again, some members may be overridden by derived classes:
    itemization(
    ithtq(overflow)
        (virtual int overflow(int c))
       (This member function may be overridden by derived classes to flush the
        characters currently stored in the output buffer to the output device,
        and then to reset the output buffer pointers so as to represent an
        empty buffer. Its parameter tt(c) is initialized to the next character
        to be processed. If no output buffering is used tt(overflow) is called
        for every single character that is written to the tt(streambuf)
        object. No output buffering is accomplished by setting the buffer
        pointers (using, tt(setp), see below) to 0. The
        i(default implementation) returns endOfFile(), indicating that no
        characters can be written to the device.

        Classes derived from tt(streambuf) for writing normally at least
        override tt(overflow). The prototypical example of an overridden
        tt(overflow) function looks like this (see also section
        ref(IOSTREAMBUF)):
 verb(int OFdStreambuf::overflow(int c)
{
    sync();                             // flush the buffer
    if (c != EOF)                       // write a character?
    {
        *pptr() = static_cast<char>(c); // put it into the buffer
        pbump(1);                       // advance the buffer's pointer
    }
    unsigned char ch = c;
    return ch;
})

)
    ithtq(pbase)
        (char *pbase())
       (tt(Streambuf) maintains three pointers controlling its output buffer:
        tt(pbase) points to the beginning of the output buffer area. See also
        figure ref(SBBUFFERS).)
    ithtq(pptr)
        (char *epptr())
       (tt(Streambuf) maintains three pointers controlling its output buffer:
        tt(epptr) points just beyond the output buffer's last available
        location. See also figure ref(SBBUFFERS). If tt(pptr) (see below)
        equals tt(epptr) the buffer must be flushed. This is implemented by
        calling tt(overflow), see before.)
    ithtq(pbump)
        (void pbump(int n))
       (The location returned by tt(pptr) (see below) is advanced by tt(n)
        positions. The next character will be written at that location.)
    ithtq(pptr)
        (char *pptr())
       (tt(Streambuf) maintains three pointers controlling its output buffer:
        tt(pptr) points to the location in the output buffer where the next
        available character will be written (note that in order to write a
        character tt(pptr()) must point to a location in the range tt(pbase())
        to tt(epptr())). See also figure ref(SBBUFFERS).)
    ithtq(setp)
        (void setp(char *beg, char *beyond))
       (tt(Streambuf)'s output buffer is initialized to the locations passed
        to tt(setp). tt(Beg) points to the beginning of the output buffer and
        tt(beyond) points just beyond the last available location of the
        output buffer. Use tt(setp(0, 0)) to indicate that i(no buffering)
        should be used. In that case tt(overflow) is called for every single
        character to be written to the device.)
    ithtq(xsputn)
        (virtual streamsize xsputn(char const *buffer, streamsize n))
       (This member function may be overridden by derived classes to write a
        series of at most tt(n) characters to the output buffer. The actual
        number of inserted characters is returned. If endOfFile() is returned
        writing to the device stops. The default implementation calls
        tt(sputc) for each individual character. Redefine this member if,
        e.g., the tt(streambuf) should support the tt(ios::openmode ios::app).
        Assuming the class tt(MyBuf), derived from tt(streambuf), features a
        data member tt(ios::openmode d_mode) (representing the requested
        tt(ios::openmode)), and a member tt(write(char const *buf, streamsize
        len)) (writing tt(len) bytes at tt(pptr())), then the following code
        acknowledges the tt(ios::app) mode (see also section
        ref(IOSTREAMBUF)):
 verb(std::streamsize MyStreambuf::xsputn(char const *buf, std::streamsize len)
{
    if (d_openMode & ios::app)
        seekoff(0, ios::end);

    return write(buf, len);
})

)
    )
