# std::strstreambuf::overflow

> C++ Atlas: `cppatlas.com/w/cpp/io/strstreambuf/overflow` | Source: https://en.cppreference.com/w/cpp/io/strstreambuf/overflow | Domain: Input/output | Standards: C++26

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

## Official Specification Summary (cppreference)

```cpp
protected:
virtual int_type overflow( int_type c = EOF ); // (deprecated in C++98) (removed in C++26)
```

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 allocating 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

```cpp
#include <iostream>
#include <strstream>

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:

```text
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`](https://en.cppreference.com/w/cpp/io/basic_streambuf/overflow) [virtual]: writes characters to the associated output sequence from the put area (virtual protected member function of `std::basic_streambuf<CharT,Traits>`)
- [`overflow`](https://en.cppreference.com/w/cpp/io/basic_stringbuf/overflow) [virtual]: appends a character to the output sequence (virtual protected member function of `std::basic_stringbuf<CharT,Traits,Allocator>`)
- [`overflow`](https://en.cppreference.com/w/cpp/io/basic_filebuf/overflow) [virtual]: writes characters to the associated file from the put area (virtual protected member function of `std::basic_filebuf<CharT,Traits>`)
- [`sputc`](https://en.cppreference.com/w/cpp/io/basic_streambuf/sputc): writes one character to the put area and advances the next pointer (public member function of `std::basic_streambuf<CharT,Traits>`)
- [`put`](https://en.cppreference.com/w/cpp/io/basic_ostream/put): inserts a character (public member function of `std::basic_ostream<CharT,Traits>`)

---
Attribution: content from https://en.cppreference.com/w/cpp/io/strstreambuf/overflow (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.