---
name: "std::basic_streambuf"
section: "3cxx"
platform: "linux"
package: "libstdc++-12-doc"
version: "12.4.0-5"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/std::basic_streambuf/3cxx"
---

# std::basic\_streambuf(3cxx)

The actual work of input and output (interface).

## NAME

std::basic\_streambuf\< \_CharT, \_Traits \> - The actual work of input and output (interface).

## SYNOPSIS

`#include <streambuf>`

Inherited by **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, **\_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**, and **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>**.

### Public Types

**typedef** \_CharT **char\_type**\
 **typedef** \_Traits **traits\_type**\
 **typedef** traits\_type::int\_type **int\_type**\
 **typedef** traits\_type::pos\_type **pos\_type**\
 **typedef** traits\_type::off\_type **off\_type**\

**typedef** **basic\_streambuf**\< **char\_type**, **traits\_type** \> **\_\_streambuf\_type**\
 This is a non-standard type.

### Public Member Functions

**virtual** **~basic\_streambuf** ()\
 Destructor deallocates no buffer space.  **locale** **getloc** () const\
 Locale access.  **streamsize** **in\_avail** ()\
 Looking ahead into the stream.  **locale** **pubimbue** (const **locale** &**\_\_loc**)\
 Entry point for imbue().  **int\_type** **sbumpc** ()\
 Getting the next character.  **int\_type** **sgetc** ()\
 Getting the next character.  **streamsize** **sgetn** (**char\_type** \***\_\_s**, **streamsize** \_\_n)\
 Entry point for xsgetn.  **int\_type** **snextc** ()\
 Getting the next character.  **int\_type** **sputbackc** (**char\_type** \_\_c)\
 Pushing characters back into the input stream.  **int\_type** **sputc** (**char\_type** \_\_c)\
 Entry point for all single-character output functions.  **streamsize** **sputn** (const **char\_type** \***\_\_s**, **streamsize** \_\_n)\
 Entry point for all single-character output functions.  **int\_type** **sungetc** ()\
 Moving backwards in the input stream.

**basic\_streambuf** \* **pubsetbuf** (**char\_type** \***\_\_s**, **streamsize** \_\_n)\
 Entry points for derived buffer functions.  **pos\_type** **pubseekoff** (**off\_type** **\_\_off**, **ios\_base::seekdir** **\_\_way**, **ios\_base::openmode** **\_\_mode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream position.  **pos\_type** **pubseekpos** (**pos\_type** **\_\_sp**, **ios\_base::openmode** **\_\_mode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream position.  int **pubsync** ()\
 Calls virtual sync function.

### Protected Member Functions

**basic\_streambuf** ()\
 Base constructor.  **basic\_streambuf** (const **basic\_streambuf** &)\
 **void** **\_\_safe\_gbump** (**streamsize** \_\_n)\
 **void** **\_\_safe\_pbump** (**streamsize** \_\_n)\
 **void** **gbump** (int \_\_n)\
 Moving the read position.  **virtual** **void** **imbue** (const **locale** &**\_\_loc**)\
 Changes translations.  **basic\_streambuf** & **operator=** (const **basic\_streambuf** &)\
 **virtual** **int\_type** **overflow** (**int\_type** \_\_c=traits\_type::eof())\
 Consumes data from the buffer; writes to the controlled sequence.  **virtual** **int\_type** **pbackfail** (**int\_type** \_\_c=traits\_type::eof())\
 Tries to back up the input sequence.  **void** **pbump** (int \_\_n)\
 Moving the write position.  **virtual** **pos\_type** **seekoff** (**off\_type**, **ios\_base::seekdir**, **ios\_base::openmode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream positions.  **virtual** **pos\_type** **seekpos** (**pos\_type**, **ios\_base::openmode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream positions.  **virtual** **basic\_streambuf**\< **char\_type**, \_Traits \> \* **setbuf** (**char\_type** \*, **streamsize**)\
 Manipulates the buffer.  **void** **setg** (**char\_type** \***\_\_gbeg**, **char\_type** \***\_\_gnext**, **char\_type** \***\_\_gend**)\
 Setting the three read area pointers.  **void** **setp** (**char\_type** \***\_\_pbeg**, **char\_type** \***\_\_pend**)\
 Setting the three write area pointers.  **virtual** **streamsize** **showmanyc** ()\
 Investigating the data available.  **void** **swap** (**basic\_streambuf** &**\_\_sb**)\
 **virtual** int **sync** ()\
 Synchronizes the buffer arrays with the controlled sequences.  **virtual** **int\_type** **uflow** ()\
 Fetches more data from the controlled sequence.  **virtual** **int\_type** **underflow** ()\
 Fetches more data from the controlled sequence.  **virtual** **streamsize** **xsgetn** (**char\_type** \***\_\_s**, **streamsize** \_\_n)\
 Multiple character extraction.  **virtual** **streamsize** **xsputn** (const **char\_type** \***\_\_s**, **streamsize** \_\_n)\
 Multiple character insertion.

**char\_type** \* **eback** () const\
 Access to the get area.  **char\_type** \* **gptr** () const\
 Access to the get area.  **char\_type** \* **egptr** () const\
 Access to the get area.

**char\_type** \* **pbase** () const\
 Access to the put area.  **char\_type** \* **pptr** () const\
 Access to the put area.  **char\_type** \* **epptr** () const\
 Access to the put area.

### Protected Attributes

**locale** **\_M\_buf\_locale**\
 Current locale setting.  **char\_type** \* **\_M\_in\_beg**\
 Start of get area.  **char\_type** \* **\_M\_in\_cur**\
 Current read area.  **char\_type** \* **\_M\_in\_end**\
 End of get area.  **char\_type** \* **\_M\_out\_beg**\
 Start of put area.  **char\_type** \* **\_M\_out\_cur**\
 Current put area.  **char\_type** \* **\_M\_out\_end**\
 End of put area.

### Friends

template\<bool \_IsMove, **typename** **\_CharT2** \> \_\_gnu\_cxx::\_\_enable\_if\< \_\_is\_char\< **\_CharT2** \>::\_\_value, **\_CharT2** \* \>::\_\_type **\_\_copy\_move\_a2** (**istreambuf\_iterator**\< **\_CharT2** \>, **istreambuf\_iterator**\< **\_CharT2** \>, **\_CharT2** \*)\
 **streamsize** **\_\_copy\_streambufs\_eof** (**basic\_streambuf** \*, **basic\_streambuf** \*, bool &)\
 **void** **\_\_istream\_extract** (**istream** &, char \*, **streamsize**)\
 template\<**typename** **\_CharT2** , **typename** **\_Distance** \> \_\_gnu\_cxx::\_\_enable\_if\< \_\_is\_char\< **\_CharT2** \>::\_\_value, **void** \>::\_\_type **advance** (**istreambuf\_iterator**\< **\_CharT2** \> &, **\_Distance**)\
 **class** **basic\_ios\< char\_type, traits\_type \>**\
 **class** **basic\_istream\< char\_type, traits\_type \>**\
 **class** **basic\_ostream\< char\_type, traits\_type \>**\
 template\<**typename** **\_CharT2** \> \_\_gnu\_cxx::\_\_enable\_if\< \_\_is\_char\< **\_CharT2** \>::\_\_value, **istreambuf\_iterator**\< **\_CharT2** \> \>::\_\_type **find** (**istreambuf\_iterator**\< **\_CharT2** \>, **istreambuf\_iterator**\< **\_CharT2** \>, const **\_CharT2** &)\
 template\<**typename** **\_CharT2** , **typename** **\_Traits2** , **typename** \_Alloc \> **basic\_istream**\< **\_CharT2**, **\_Traits2** \> & **getline** (**basic\_istream**\< **\_CharT2**, **\_Traits2** \> &, **basic\_string**\< **\_CharT2**, **\_Traits2**, \_Alloc \> &, **\_CharT2**)\
 **class** **istreambuf\_iterator\< char\_type, traits\_type \>**\
 template\<**typename** **\_CharT2** , **typename** **\_Traits2** , **typename** \_Alloc \> **basic\_istream**\< **\_CharT2**, **\_Traits2** \> & **operator\>\>** (**basic\_istream**\< **\_CharT2**, **\_Traits2** \> &, **basic\_string**\< **\_CharT2**, **\_Traits2**, \_Alloc \> &)\
 **class** **ostreambuf\_iterator\< char\_type, traits\_type \>**\

## Detailed Description

### template\<typename \_CharT, typename \_Traits\>

class std::basic\_streambuf\< \_CharT, \_Traits \>"The actual work of input and output (interface).

**Template Parameters**

*\_CharT* Type of character stream. \
 *\_Traits* Traits for character type, defaults to char\_traits\<\_CharT\>.

This is a base class. Derived stream buffers each control a pair of character sequences: one for input, and one for output.

Section \[27.5.1\] of the standard describes the requirements and behavior of stream buffer classes. That section (three paragraphs) is reproduced here, for simplicity and accuracy.

- 1\.

  Stream buffers can impose various constraints on the sequences they control. Some constraints are:

- •

  The controlled input sequence can be not readable.

- •

  The controlled output sequence can be not writable.

- •

  The controlled sequences can be associated with the contents of other representations for character sequences, such as external files.

- •

  The controlled sequences can support operations *directly* to or from associated sequences.

- •

  The controlled sequences can impose limitations on how the program can read characters from a sequence, write characters to a sequence, put characters back into an input sequence, or alter the stream position.

- 2\.

  Each sequence is characterized by three pointers which, if non-null, all point into the same `charT` array object. The array object represents, at any moment, a (sub)sequence of characters from the sequence. Operations performed on a sequence alter the values stored in these pointers, perform reads and writes directly to or from associated sequences, and alter *the stream position* and conversion state as needed to maintain this subsequence relationship. The three pointers are:

- •

  the *beginning pointer*, or lowest element address in the array (called *xbeg* here);

- •

  the *next pointer*, or next element address that is a current candidate for reading or writing (called *xnext* here);

- •

  the *end pointer*, or first element address beyond the end of the array (called *xend* here).

- 3\.

  The following semantic constraints shall always apply for any set of three pointers for a sequence, using the pointer names given immediately above:

- •

  If *xnext* is not a null pointer, then *xbeg* and *xend* shall also be non-null pointers into the same `charT` array, as described above; otherwise, *xbeg* and *xend* shall also be null.

- •

  If *xnext* is not a null pointer and *xnext* \< *xend* for an output sequence, then a *write position* is available. In this case, *\*xnext* shall be assignable as the next element to write (to put, or to store a character value, into the sequence).

- •

  If *xnext* is not a null pointer and *xbeg* \< *xnext* for an input sequence, then a *putback position* is available. In this case, *xnext*\[-1\] shall have a defined value and is the next (preceding) element to store a character that is put back into the input sequence.

- •

  If *xnext* is not a null pointer and *xnext\<* *xend* for an input sequence, then a *read position* is available. In this case, *\*xnext* shall have a defined value and is the next element to read (to get, or to obtain a character value, from the sequence).

## Member Typedef Documentation

### template\<typename \_CharT , typename \_Traits \> typedef basic\_streambuf\<char\_type, traits\_type\> std::basic\_streambuf\< \_CharT, \_Traits \>::\_\_streambuf\_type

This is a non-standard type.

### template\<typename \_CharT , typename \_Traits \> typedef \_CharT std::basic\_streambuf\< \_CharT, \_Traits \>::char\_type

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

### template\<typename \_CharT , typename \_Traits \> typedef traits\_type::int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::int\_type

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

### template\<typename \_CharT , typename \_Traits \> typedef traits\_type::off\_type std::basic\_streambuf\< \_CharT, \_Traits \>::off\_type

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

### template\<typename \_CharT , typename \_Traits \> typedef traits\_type::pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pos\_type

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

### template\<typename \_CharT , typename \_Traits \> typedef \_Traits std::basic\_streambuf\< \_CharT, \_Traits \>::traits\_type

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

## Constructor & Destructor Documentation

### template\<typename \_CharT , typename \_Traits \> virtual std::basic\_streambuf\< \_CharT, \_Traits \>::~basic\_streambuf ()` [inline]`, ` [virtual]`

Destructor deallocates no buffer space.

### template\<typename \_CharT , typename \_Traits \> std::basic\_streambuf\< \_CharT, \_Traits \>::basic\_streambuf ()` [inline]`, ` [protected]`

Base constructor. Only called from derived constructors, and sets up all the buffer data to zero, including the pointers described in the basic\_streambuf class description. Note that, as a result,

- •

  the class starts with no read nor write positions available,

- •

  this is not an error

## Member Function Documentation

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::eback () const` [inline]`, ` [protected]`

Access to the get area. These functions are only available to other protected functions, including derived classes.

- •

  eback() returns the beginning pointer for the input sequence

- •

  gptr() returns the next pointer for the input sequence

- •

  egptr() returns the end pointer for the input sequence

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::egptr () const` [inline]`, ` [protected]`

Access to the get area. These functions are only available to other protected functions, including derived classes.

- •

  eback() returns the beginning pointer for the input sequence

- •

  gptr() returns the next pointer for the input sequence

- •

  egptr() returns the end pointer for the input sequence

Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::underflow()**.

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::epptr () const` [inline]`, ` [protected]`

Access to the put area. These functions are only available to other protected functions, including derived classes.

- •

  pbase() returns the beginning pointer for the output sequence

- •

  pptr() returns the next pointer for the output sequence

- •

  epptr() returns the end pointer for the output sequence

### template\<typename \_CharT , typename \_Traits \> void std::basic\_streambuf\< \_CharT, \_Traits \>::gbump (int \_\_n)` [inline]`, ` [protected]`

Moving the read position.

**Parameters**

*\_\_n* The delta by which to move.

This just advances the read position without returning any data.

### template\<typename \_CharT , typename \_Traits \> locale std::basic\_streambuf\< \_CharT, \_Traits \>::getloc () const` [inline]`

Locale access.

**Returns**

The current locale in effect.

If pubimbue(loc) has been called, then the most recent `loc` is returned. Otherwise the global locale in effect at the time of construction is returned.

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::gptr () const` [inline]`, ` [protected]`

Access to the get area. These functions are only available to other protected functions, including derived classes.

- •

  eback() returns the beginning pointer for the input sequence

- •

  gptr() returns the next pointer for the input sequence

- •

  egptr() returns the end pointer for the input sequence

Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::underflow()**.

### template\<typename \_CharT , typename \_Traits \> virtual void std::basic\_streambuf\< \_CharT, \_Traits \>::imbue (const locale & \_\_loc)` [inline]`, ` [protected]`, ` [virtual]`

Changes translations.

**Parameters**

*\_\_loc* A new locale.

Translations done during I/O which depend on the current locale are changed by this call. The standard adds, *Between invocations of this function a class derived from streambuf can safely cache results of calls to locale functions and to members of facets so obtained.*

**Note**

Base class version does nothing.

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, and **std::basic\_filebuf\< char\_type, traits\_type \>**.

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::in\_avail ()` [inline]`

Looking ahead into the stream.

**Returns**

The number of characters available.

If a read position is available, returns the number of characters available for reading before the buffer must be refilled. Otherwise returns the derived `showmanyc()`.

### template\<typename \_CharT , typename \_Traits \> virtual int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::overflow (int\_type \_\_c = `traits_type::eof()`)` [inline]`, ` [protected]`, ` [virtual]`

Consumes data from the buffer; writes to the controlled sequence.

**Parameters**

*\_\_c* An additional character to consume.

**Returns**

eof() to indicate failure, something else (usually *\_\_c*, or not\_eof())

Informally, this function is called when the output buffer is full (or does not exist, as buffering need not actually be done). If a buffer exists, it is *consumed*, with *some effect* on the controlled sequence. (Typically, the buffer is written out to the sequence verbatim.) In either case, the character *c* is also written out, if *\_\_c* is not `eof()`.

For a formal definition of this function, see a good text such as Langer & Kreft, or \[27.5.2.4.5\]/3-7.

A functioning output streambuf can be created by overriding only this function (no buffer area will be used).

**Note**

Base class version does nothing, returns eof().

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, **\_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**, and **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>**.

### template\<typename \_CharT , typename \_Traits \> virtual int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pbackfail (int\_type \_\_c = `traits_type::eof()`)` [inline]`, ` [protected]`, ` [virtual]`

Tries to back up the input sequence.

**Parameters**

*\_\_c* The character to be inserted back into the sequence.

**Returns**

eof() on failure, *some other value* on success

**Postcondition**

The constraints of `gptr()`, `eback()`, and `pptr()` are the same as for `underflow()`.

**Note**

Base class version does nothing, returns eof().

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, **\_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>**, and **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**.

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::pbase () const` [inline]`, ` [protected]`

Access to the put area. These functions are only available to other protected functions, including derived classes.

- •

  pbase() returns the beginning pointer for the output sequence

- •

  pptr() returns the next pointer for the output sequence

- •

  epptr() returns the end pointer for the output sequence

### template\<typename \_CharT , typename \_Traits \> void std::basic\_streambuf\< \_CharT, \_Traits \>::pbump (int \_\_n)` [inline]`, ` [protected]`

Moving the write position.

**Parameters**

*\_\_n* The delta by which to move.

This just advances the write position without returning any data.

### template\<typename \_CharT , typename \_Traits \> char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::pptr () const` [inline]`, ` [protected]`

Access to the put area. These functions are only available to other protected functions, including derived classes.

- •

  pbase() returns the beginning pointer for the output sequence

- •

  pptr() returns the next pointer for the output sequence

- •

  epptr() returns the end pointer for the output sequence

### template\<typename \_CharT , typename \_Traits \> locale std::basic\_streambuf\< \_CharT, \_Traits \>::pubimbue (const locale & \_\_loc)` [inline]`

Entry point for imbue().

**Parameters**

*\_\_loc* The new locale.

**Returns**

The previous locale.

Calls the derived imbue(\_\_loc).

### template\<typename \_CharT , typename \_Traits \> pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pubseekoff (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode = ios\_base::in` | `ios\_base::out)` [inline]`

Alters the stream position.

**Parameters**

*\_\_off* Offset. \
 *\_\_way* Value for ios\_base::seekdir. \
 *\_\_mode* Value for ios\_base::openmode.

Calls virtual seekoff function.

### template\<typename \_CharT , typename \_Traits \> pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pubseekpos (pos\_type \_\_sp, ios\_base::openmode \_\_mode = ios\_base::in` | `ios\_base::out)` [inline]`

Alters the stream position.

**Parameters**

*\_\_sp* Position \
 *\_\_mode* Value for ios\_base::openmode.

Calls virtual seekpos function.

### template\<typename \_CharT , typename \_Traits \> basic\_streambuf \* std::basic\_streambuf\< \_CharT, \_Traits \>::pubsetbuf (char\_type \* \_\_s, streamsize \_\_n)` [inline]`

Entry points for derived buffer functions. The public versions of `pubfoo` dispatch to the protected derived `foo` member functions, passing the arguments (if any) and returning the result unchanged.

### template\<typename \_CharT , typename \_Traits \> int std::basic\_streambuf\< \_CharT, \_Traits \>::pubsync ()` [inline]`

Calls virtual sync function.

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sbumpc ()` [inline]`

Getting the next character.

**Returns**

The next character, or eof.

If the input read position is available, returns that character and increments the read pointer, otherwise calls and returns `uflow()`.

### template\<typename \_CharT , typename \_Traits \> virtual pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::seekoff (off\_type, ios\_base::seekdir, ios\_base::openmode = ios\_base::in` | `ios\_base::out)` [inline]`, ` [protected]`, ` [virtual]`

Alters the stream positions. Each derived class provides its own appropriate behavior.

**Note**

Base class version does nothing, returns a `pos_type` that represents an invalid stream position.

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, and **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**.

### template\<typename \_CharT , typename \_Traits \> virtual pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::seekpos (pos\_type, ios\_base::openmode = ios\_base::in` | `ios\_base::out)` [inline]`, ` [protected]`, ` [virtual]`

Alters the stream positions. Each derived class provides its own appropriate behavior.

**Note**

Base class version does nothing, returns a `pos_type` that represents an invalid stream position.

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, and **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**.

### template\<typename \_CharT , typename \_Traits \> virtual basic\_streambuf\< char\_type, \_Traits \> \* std::basic\_streambuf\< \_CharT, \_Traits \>::setbuf (char\_type \*, streamsize)` [inline]`, ` [protected]`, ` [virtual]`

Manipulates the buffer. Each derived class provides its own appropriate behavior. See the next-to-last paragraph of https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering for more on this function.

**Note**

Base class version does nothing, returns `this`.

Reimplemented in **std::basic\_filebuf\< \_CharT, \_Traits \>**, **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>**, **std::basic\_filebuf\< char\_type, traits\_type \>**, and **std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>**.

### template\<typename \_CharT , typename \_Traits \> void std::basic\_streambuf\< \_CharT, \_Traits \>::setg (char\_type \* \_\_gbeg, char\_type \* \_\_gnext, char\_type \* \_\_gend)` [inline]`, ` [protected]`

Setting the three read area pointers.

**Parameters**

*\_\_gbeg* A pointer. \
 *\_\_gnext* A pointer. \
 *\_\_gend* A pointer.

**Postcondition**

*\_\_gbeg* == `eback()`, *\_\_gnext* == `gptr()`, and *\_\_gend* == `egptr()`

Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::wbuffer\_convert()**.

### template\<typename \_CharT , typename \_Traits \> void std::basic\_streambuf\< \_CharT, \_Traits \>::setp (char\_type \* \_\_pbeg, char\_type \* \_\_pend)` [inline]`, ` [protected]`

Setting the three write area pointers.

**Parameters**

*\_\_pbeg* A pointer. \
 *\_\_pend* A pointer.

**Postcondition**

*\_\_pbeg* == `pbase()`, *\_\_pbeg* == `pptr()`, and *\_\_pend* == `epptr()`

Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::wbuffer\_convert()**.

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sgetc ()` [inline]`

Getting the next character.

**Returns**

The next character, or eof.

If the input read position is available, returns that character, otherwise calls and returns `underflow()`. Does not move the read position after fetching the character.

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::sgetn (char\_type \* \_\_s, streamsize \_\_n)` [inline]`

Entry point for xsgetn.

**Parameters**

*\_\_s* A buffer area. \
 *\_\_n* A count.

Returns xsgetn(\_\_s,\_\_n). The effect is to fill *\_\_s*\[0\] through *\_\_s*\[\_\_n-1\] with characters from the input sequence, if possible.

### template\<typename \_CharT , typename \_Traits \> virtual streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::showmanyc ()` [inline]`, ` [protected]`, ` [virtual]`

Investigating the data available.

**Returns**

An estimate of the number of characters available in the input sequence, or -1.

*If it returns a positive value, then successive calls to* `underflow()` *will not return* `traits::eof()` *until at least that number of characters have been supplied. If* `showmanyc()` *returns -1, then calls to* `underflow()` *or* `uflow()` *will fail.*` [27.5.2.4.3]/1`

**Note**

`Base class version does nothing, returns zero. `

`The standard adds that `*the intention is not only that the calls \[to underflow or uflow\] will not return* `eof()` *but that they will return immediately.*` `

`The standard adds that `*the morphemes of* `showmanyc` *are* **es-how-many-see***, not* **show-manic***.*

**Reimplemented in std::basic\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>, std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>, std::basic\_filebuf\< char\_type, traits\_type \>, and std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>.**

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::snextc ()` [inline]`

**Getting the next character.**

**Returns**

**The next character, or eof.**

**Calls** `sbumpc()`**, and if that function returns** `traits::eof()`**, so does this function. Otherwise,** `sgetc()`**.**

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sputbackc (char\_type \_\_c)` [inline]`

**Pushing characters back into the input stream.**

**Parameters**

*\_\_c* **The character to push back.**

**Returns**

**The previous character, if possible.**

**Similar to sungetc(), but** *\_\_c* **is pushed onto the stream instead of** *the previous character.* **If successful, the next character fetched from the input stream will be** *\_\_c***.**

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sputc (char\_type \_\_c)` [inline]`

**Entry point for all single-character output functions.**

**Parameters**

*\_\_c* **A character to output.**

**Returns**

*\_\_c***, if possible.**

**One of two public output functions.**

**If a write position is available for the output sequence (i.e., the buffer is not full), stores** *\_\_c* **in that position, increments the position, and returns** `traits::to_int_type(__c)`**. If a write position is not available, returns** `overflow(__c)`**.**

**Referenced by std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::overflow().**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::sputn (const char\_type \* \_\_s, streamsize \_\_n)` [inline]`

**Entry point for all single-character output functions.**

**Parameters**

*\_\_s* **A buffer read area.** \
 *\_\_n* **A count.**

**One of two public output functions.**

**Returns xsputn(\_\_s,\_\_n). The effect is to write** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] to the output sequence, if possible.**

### template\<typename \_CharT , typename \_Traits \> int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sungetc ()` [inline]`

**Moving backwards in the input stream.**

**Returns**

**The previous character, if possible.**

**If a putback position is available, this function decrements the input pointer and returns that character. Otherwise, calls and returns pbackfail(). The effect is to** *unget* **the last character** *gotten***.**

### template\<typename \_CharT , typename \_Traits \> virtual int std::basic\_streambuf\< \_CharT, \_Traits \>::sync ()` [inline]`, ` [protected]`, ` [virtual]`

**Synchronizes the buffer arrays with the controlled sequences.**

**Returns**

**-1 on failure.**

**Each derived class provides its own appropriate behavior, including the definition of** *failure***.**

**Note**

**Base class version does nothing, returns zero.**

**Reimplemented in std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>, \_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>, std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>, and std::basic\_filebuf\< char\_type, traits\_type \>.**

### template\<typename \_CharT , typename \_Traits \> virtual int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::uflow ()` [inline]`, ` [protected]`, ` [virtual]`

**Fetches more data from the controlled sequence.**

**Returns**

**The first character from the** *pending sequence***.**

**Informally, this function does the same thing as** `underflow()`**, and in fact is required to call that function. It also returns the new character, like** `underflow()` **does. However, this function also moves the read position forward by one.**

**Reimplemented in \_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>.**

### template\<typename \_CharT , typename \_Traits \> virtual int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::underflow ()` [inline]`, ` [protected]`, ` [virtual]`

**Fetches more data from the controlled sequence.**

**Returns**

**The first character from the** *pending sequence***.**

**Informally, this function is called when the input buffer is exhausted (or does not exist, as buffering need not actually be done). If a buffer exists, it is** *refilled***. In either case, the next available character is returned, or** `traits::eof()` **to indicate a null pending sequence.**

**For a formal definition of the pending sequence, see a good text such as Langer & Kreft, or \[27.5.2.4.3\]/7-14.**

**A functioning input streambuf can be created by overriding only this function (no buffer area will be used). For an example, see https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html**

**Note**

**Base class version does nothing, returns eof().**

**Reimplemented in std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>, \_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>, std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>, std::basic\_filebuf\< char\_type, traits\_type \>, and std::basic\_stringbuf\< \_CharT, \_Traits, \_Alloc \>.**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::xsgetn (char\_type \* \_\_s, streamsize \_\_n)` [protected]`, ` [virtual]`

**Multiple character extraction.**

**Parameters**

*\_\_s* **A buffer area.** \
 *\_\_n* **Maximum number of characters to assign.**

**Returns**

**The number of characters assigned.**

**Fills** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] with characters from the input sequence, as if by** `sbumpc()`**. Stops when either** *\_\_n* **characters have been copied, or when** `traits::eof()` **would be copied.**

**It is expected that derived classes provide a more efficient implementation by overriding this definition.**

**Reimplemented in std::basic\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>, std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>, and std::basic\_filebuf\< char\_type, traits\_type \>.**

**References std::min().**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::xsputn (const char\_type \* \_\_s, streamsize \_\_n)` [protected]`, ` [virtual]`

**Multiple character insertion.**

**Parameters**

*\_\_s* **A buffer area.** \
 *\_\_n* **Maximum number of characters to write.**

**Returns**

**The number of characters written.**

**Writes** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] to the output sequence, as if by** `sputc()`**. Stops when either** *n* **characters have been copied, or when** `sputc()` **would return** `traits::eof()`**.**

**It is expected that derived classes provide a more efficient implementation by overriding this definition.**

**Reimplemented in std::basic\_filebuf\< \_CharT, \_Traits \>, std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>, std::basic\_filebuf\< \_CharT, std::char\_traits\< \_CharT \> \>, and std::basic\_filebuf\< char\_type, traits\_type \>.**

**References std::min().**

## Member Data Documentation

### template\<typename \_CharT , typename \_Traits \> locale std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_buf\_locale` [protected]`

**Current locale setting.**

**Referenced by std::basic\_filebuf\< \_CharT, \_Traits \>::basic\_filebuf().**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_beg` [protected]`

**Start of get area.**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_cur` [protected]`

**Current read area.**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_end` [protected]`

**End of get area.**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_beg` [protected]`

**Start of put area.**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_cur` [protected]`

**Current put area.**

### template\<typename \_CharT , typename \_Traits \> char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_end` [protected]`

**End of put area.**

## Author

**Generated automatically by Doxygen for libstdc++ from the source code.**