std::strstreambuf::overflow

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Input/output library

I/O manipulators

C-style I/O

Buffers

basic_streambuf

basic_filebuf

basic_stringbuf

strstreambuf (deprecated)

Streams

Abstractions

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

File I/O

basic_ifstream

basic_ofstream

basic_fstream

String I/O

basic_istringstream

basic_ostringstream

basic_stringstream

Array I/O

istrstream (deprecated)

ostrstream (deprecated)

strstream (deprecated)

Types

streamoff

streamsize

fpos

Error category interface

iostream_category (C++11)

io_errc (C++11)

 

std::strstreambuf

Public member functions

strstreambuf::strstreambuf

strstreambuf::~strstreambuf

strstreambuf::freeze

strstreambuf::str

strstreambuf::pcount

Protected member functions

strstreambuf::underflow

strstreambuf::pbackfail

strstreambuf::overflow

strstreambuf::setbuf

strstreambuf::seekoff

strstreambuf::seekpos

 

protected: virtual int_type overflow (int_type c = EOF);

Appends the character c to the put area of the buffer, reallocating if possible.

1) If c==EOF, does nothing

2) Otherwise, if the put area has a write position available (pptr() < epptr()), stores the character as if by *pptr()++ = c

3) Otherwise, if the stream buffer mode is not dynamic or the stream buffer is currently frozen, the function fails and returns EOF

4) Otherwise, the function reallocates (or initially allocates) a dynamic array large enough to hold the contents of the current dynamic array (if any) plus at least one additional write position. If a pointer to the allocator function palloc was used in the constructor, that function is called with (*palloc)[n] where n is the number of bytes to allocate, otherwise new char[n] is used. If a pointer to the deallocating function pfree was used in the constructor, that function is called with (*pfree)(p) to deallocate the previous array, if needed, otherwise delete[] p is used. If allocation fails, the function fails and returns EOF.

Parameters

c

-

the character to store in the put area

Return value

If c==EOF, returns some value other than EOF. Otherwise, returns (unsigned char)(c) on success, EOF on failure.

Example

Run this code

#include <strstream>
#include <iostream>
 
struct mybuf : std::strstreambuf
{
    int_type overflow(int_type c) 
    {
        std::cout << "Before overflow(): size of the put area is " << epptr()-pbase()
                  << " with " << epptr()-pptr() << " write positions available\n";
        int_type rc = std::strstreambuf::overflow(c);
        std::cout << "After overflow(): size of the put area is " << epptr()-pbase()
                  << " with " << epptr()-pptr() << " write positions available\n";
        return rc;
    }
};
 
int main()
{
    mybuf sbuf; // read-write dynamic strstreambuf
    std::iostream stream(&sbuf);
 
    stream << "Sufficiently long string to overflow the initial allocation, at least "
           << " on some systems.";
}

Possible output:

Before overflow(): size of the put area is 16 with 0 write positions available
After overflow(): size of the put area is 32 with 15 write positions available
Before overflow(): size of the put area is 32 with 0 write positions available
After overflow(): size of the put area is 64 with 31 write positions available
Before overflow(): size of the put area is 64 with 0 write positions available
After overflow(): size of the put area is 128 with 63 write positions available

See also

overflow [virtual]	writes characters to the associated output sequence from the put area (virtual protected member function of std::basic_streambuf)
overflow [virtual]	appends a character to the output sequence (virtual protected member function of std::basic_stringbuf)
overflow [virtual]	writes characters to the associated file from the put area (virtual protected member function of std::basic_filebuf)
sputc	writes one character to the put area and advances the next pointer (public member function of std::basic_streambuf)
put	inserts a character (public member function of std::basic_ostream)