---
name: "std::basic_filebuf"
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_filebuf/3cxx"
---

# std::basic\_filebuf(3cxx)

The actual work of input and output (for files).

## NAME

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

## SYNOPSIS

`#include <fstream>`

Inherits **std::basic\_streambuf\< \_CharT, \_Traits \>**.

Inherited by **\_\_gnu\_cxx::stdio\_filebuf\< \_CharT, \_Traits \>**.

### Public Types

**typedef** **codecvt**\< char\_type, char, \_\_state\_type \> **\_\_codecvt\_type**\
 **typedef** \_\_basic\_file\< char \> **\_\_file\_type**\
 **typedef** **basic\_filebuf**\< char\_type, traits\_type \> **\_\_filebuf\_type**\
 **typedef** traits\_type::state\_type **\_\_state\_type**\
 **typedef** **basic\_streambuf**\< char\_type, traits\_type \> **\_\_streambuf\_type**\
 **typedef** \_CharT **char\_type**\
 **typedef** traits\_type::int\_type **int\_type**\
 **typedef** traits\_type::off\_type **off\_type**\
 **typedef** traits\_type::pos\_type **pos\_type**\
 **typedef** \_Traits **traits\_type**\

### Public Member Functions

**basic\_filebuf** ()\
 Does not open any files.  **basic\_filebuf** (**basic\_filebuf** &&)\
 **basic\_filebuf** (const **basic\_filebuf** &)=**delete**\
 **virtual** **~basic\_filebuf** ()\
 The destructor closes the file first.  **\_\_filebuf\_type** \* **close** ()\
 Closes the currently associated file.  **locale** **getloc** () const\
 Locale access.  **streamsize** **in\_avail** ()\
 Looking ahead into the stream.  bool **is\_open** () const  **throw** ()\
 Returns true if the external file is open.  template\<**typename** **\_Path** \> **\_If\_fs\_path**\< **\_Path**, **\_\_filebuf\_type** \* \> **open** (const **\_Path** &**\_\_s**, **ios\_base::openmode** **\_\_mode**)\
 Opens an external file.  **\_\_filebuf\_type** \* **open** (const char \***\_\_s**, **ios\_base::openmode** **\_\_mode**)\
 Opens an external file.  **\_\_filebuf\_type** \* **open** (const **std::string** &**\_\_s**, **ios\_base::openmode** **\_\_mode**)\
 Opens an external file.  **basic\_filebuf** & **operator=** (**basic\_filebuf** &&)\
 **basic\_filebuf** & **operator=** (const **basic\_filebuf** &)=**delete**\
 **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.  **void** **swap** (**basic\_filebuf** &)\

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

**void** **\_\_safe\_gbump** (**streamsize** \_\_n)\
 **void** **\_\_safe\_pbump** (**streamsize** \_\_n)\
 **void** **\_M\_allocate\_internal\_buffer** ()\
 bool **\_M\_convert\_to\_external** (char\_type \*, **streamsize**)\
 **void** **\_M\_create\_pback** ()\
 **void** **\_M\_destroy\_internal\_buffer** ()  **throw** ()\
 **void** **\_M\_destroy\_pback** ()  **throw** ()\
 int **\_M\_get\_ext\_pos** (\_\_state\_type &**\_\_state**)\
 pos\_type **\_M\_seek** (off\_type **\_\_off**, **ios\_base::seekdir** **\_\_way**, \_\_state\_type **\_\_state**)\
 **void** **\_M\_set\_buffer** (**streamsize** **\_\_off**)\
 bool **\_M\_terminate\_output** ()\
 **void** **gbump** (int \_\_n)\
 Moving the read position.  **virtual** **void** **imbue** (const **locale** &**\_\_loc**)\
 Changes translations.  **virtual** int\_type **overflow** (int\_type \_\_c=\_Traits::eof())\
 Consumes data from the buffer; writes to the controlled sequence.  **virtual** int\_type **pbackfail** (int\_type \_\_c=\_Traits::eof())\
 Tries to back up the input sequence.  **void** **pbump** (int \_\_n)\
 Moving the write position.  **virtual** pos\_type **seekoff** (off\_type **\_\_off**, **ios\_base::seekdir** **\_\_way**, **ios\_base::openmode** **\_\_mode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream positions.  **virtual** pos\_type **seekpos** (pos\_type **\_\_pos**, **ios\_base::openmode** **\_\_mode**=**ios\_base::in**\|**ios\_base::out**)\
 Alters the stream positions.  **virtual** **\_\_streambuf\_type** \* **setbuf** (char\_type \***\_\_s**, **streamsize** \_\_n)\
 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

char\_type \* **\_M\_buf**\
 Pointer to the beginning of internal buffer.  bool **\_M\_buf\_allocated**\
 **locale** **\_M\_buf\_locale**\
 Current locale setting.  size\_t **\_M\_buf\_size**\
 const **\_\_codecvt\_type** \* **\_M\_codecvt**\
 char \* **\_M\_ext\_buf**\
 **streamsize** **\_M\_ext\_buf\_size**\
 char \* **\_M\_ext\_end**\
 const char \* **\_M\_ext\_next**\
 \_\_file\_type **\_M\_file**\
 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.  \_\_c\_lock **\_M\_lock**\
 **ios\_base::openmode** **\_M\_mode**\
 Place to stash in \|\| out \|\| in \| out settings for current filebuf.  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.  bool **\_M\_reading**\
 \_\_state\_type **\_M\_state\_beg**\
 \_\_state\_type **\_M\_state\_cur**\
 \_\_state\_type **\_M\_state\_last**\
 bool **\_M\_writing**\

char\_type **\_M\_pback**\
 char\_type \* **\_M\_pback\_cur\_save**\
 char\_type \* **\_M\_pback\_end\_save**\
 bool **\_M\_pback\_init**\

### Friends

**class** **ios\_base**\

## Detailed Description

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

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

**Template Parameters**

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

This class associates both its input and output sequence with an external disk file, and maintains a joint file position for both sequences. Many of its semantics are described in terms of similar behavior in the Standard C Library's `FILE` streams.

Requirements on traits\_type, specific to this class:

- •

  traits\_type::pos\_type must be fpos\<traits\_type::state\_type\>

- •

  traits\_type::off\_type must be streamoff

- •

  traits\_type::state\_type must be Assignable and DefaultConstructible,

- •

  traits\_type::state\_type() must be the initial state for codecvt.

## Constructor & Destructor Documentation

### template\<typename \_CharT , typename \_Traits \> std::basic\_filebuf\< \_CharT, \_Traits \>::basic\_filebuf ()

Does not open any files. The default constructor initializes the parent class using its own default ctor.

References **std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_buf\_locale**.

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

The destructor closes the file first.

## Member Function Documentation

### template\<typename \_CharT , typename \_Traits \> void std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_create\_pback ()` [inline]`, ` [protected]`

Initializes pback buffers, and moves normal buffers to safety. Assumptions: \_M\_in\_cur has already been moved back

### template\<typename \_CharT , typename \_Traits \> void std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_destroy\_pback ()` [inline]`, ` [protected]`

Deactivates pback buffer contents, and restores normal buffer. Assumptions: The pback buffer has only moved forward.

### template\<typename \_CharT , typename \_Traits \> void std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_set\_buffer (streamsize \_\_off)` [inline]`, ` [protected]`

This function sets the pointers of the internal buffer, both get and put areas. Typically:

\_\_off == egptr() - eback() upon underflow/uflow (**read** mode); \_\_off == 0 upon overflow (**write** mode); \_\_off == -1 upon open, setbuf, seekoff/pos (**uncommitted** mode).

NB: epptr() - pbase() == \_M\_buf\_size - 1, since \_M\_buf\_size reflects the actual allocated memory and the last cell is reserved for the overflow char of a full put area.

### template\<typename \_CharT , typename \_Traits \> basic\_filebuf\< \_CharT, \_Traits \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, \_Traits \>::close ()

Closes the currently associated file.

**Returns**

`this` on success, NULL on failure

If no file is currently open, this function immediately fails.

If a *put buffer area* exists, `overflow(eof)` is called to flush all the characters. The file is then closed.

If any operations fail, this function also fails.

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

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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 \> void std::basic\_filebuf\< \_CharT, \_Traits \>::imbue (const locale & \_\_loc)` [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 from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

References **std::ios\_base::cur**.

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

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 \> bool std::basic\_filebuf\< \_CharT, \_Traits \>::is\_open () const` [inline]`

Returns true if the external file is open.

### template\<typename \_CharT , typename \_Traits \> template\<typename \_Path \> \_If\_fs\_path\< \_Path, \_\_filebuf\_type \* \> std::basic\_filebuf\< \_CharT, \_Traits \>::open (const \_Path & \_\_s, ios\_base::openmode \_\_mode)` [inline]`

Opens an external file.

**Parameters**

*\_\_s* The name of the file, as a filesystem::path. \
 *\_\_mode* The open mode flags.

**Returns**

`this` on success, NULL on failure

### template\<typename \_CharT , typename \_Traits \> basic\_filebuf\< \_CharT, \_Traits \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, \_Traits \>::open (const char \* \_\_s, ios\_base::openmode \_\_mode)

Opens an external file.

**Parameters**

*\_\_s* The name of the file. \
 *\_\_mode* The open mode flags.

**Returns**

`this` on success, NULL on failure

If a file is already open, this function immediately fails. Otherwise it tries to open the file named *\_\_s* using the flags given in *\_\_mode*.

Table 92, adapted here, gives the relation between openmode combinations and the equivalent `fopen()` flags. (NB: lines app, in\|out\|app, in\|app, binary\|app, binary\|in\|out\|app, and binary\|in\|app per DR 596)

```
+---------------------------------------------------------+
| ios_base Flag combination            stdio equivalent   |
|binary  in  out  trunc  app                              |
+---------------------------------------------------------+
|             +                        w                  |
|             +           +            a                  |
|                         +            a                  |
|             +     +                  w                  |
|         +                            r                  |
|         +   +                        r+                 |
|         +   +     +                  w+                 |
|         +   +           +            a+                 |
|         +               +            a+                 |
+---------------------------------------------------------+
|   +         +                        wb                 |
|   +         +           +            ab                 |
|   +                     +            ab                 |
|   +         +     +                  wb                 |
|   +     +                            rb                 |
|   +     +   +                        r+b                |
|   +     +   +     +                  w+b                |
|   +     +   +           +            a+b                |
|   +     +               +            a+b                |
+---------------------------------------------------------+
```

References **std::ios\_base::ate**, and **std::ios\_base::end**.

### template\<typename \_CharT , typename \_Traits \> \_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, \_Traits \>::open (const std::string & \_\_s, ios\_base::openmode \_\_mode)` [inline]`

Opens an external file.

**Parameters**

*\_\_s* The name of the file. \
 *\_\_mode* The open mode flags.

**Returns**

`this` on success, NULL on failure

### template\<typename \_CharT , typename \_Traits \> basic\_filebuf\< \_CharT, \_Traits \>::int\_type std::basic\_filebuf\< \_CharT, \_Traits \>::overflow (int\_type \_\_c = `_Traits::eof()`)` [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 from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

References **std::ios\_base::app**, **std::ios\_base::cur**, and **std::ios\_base::out**.

### template\<typename \_CharT , typename \_Traits \> basic\_filebuf\< \_CharT, \_Traits \>::int\_type std::basic\_filebuf\< \_CharT, \_Traits \>::pbackfail (int\_type \_\_c = `_Traits::eof()`)` [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 from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

References **std::ios\_base::cur**, and **std::ios\_base::in**.

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

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

Calls virtual sync function.

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

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 \> basic\_filebuf\< \_CharT, \_Traits \>::pos\_type std::basic\_filebuf\< \_CharT, \_Traits \>::seekoff (off\_type, ios\_base::seekdir, ios\_base::openmode = ios\_base::in` | `ios\_base::out)` [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 from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

References **std::ios\_base::cur**.

### template\<typename \_CharT , typename \_Traits \> basic\_filebuf\< \_CharT, \_Traits \>::pos\_type std::basic\_filebuf\< \_CharT, \_Traits \>::seekpos (pos\_type, ios\_base::openmode = ios\_base::in` | `ios\_base::out)` [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 from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

References **std::ios\_base::beg**.

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

Manipulates the buffer.

**Parameters**

*\_\_s* Pointer to a buffer area. \
 *\_\_n* Size of *\_\_s*.

**Returns**

`this`

If no file has been opened, and both *\_\_s* and *\_\_n* are zero, then the stream becomes unbuffered. Otherwise, `__s` is used as a buffer; see https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering for more.

Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**.

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

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]`, ` [inherited]`

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]`, ` [inherited]`

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]`, ` [inherited]`

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 \> streamsize std::basic\_filebuf\< \_CharT, \_Traits \>::showmanyc ()` [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 from std::basic\_streambuf\< \_CharT, \_Traits \>.**

**References std::ios\_base::binary, and std::ios\_base::in.**

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

**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]`, ` [inherited]`

**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]`, ` [inherited]`

**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]`, ` [inherited]`

**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]`, ` [inherited]`

**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 \> int std::basic\_filebuf\< \_CharT, \_Traits \>::sync ()` [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 from std::basic\_streambuf\< \_CharT, \_Traits \>.**

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

**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 \> basic\_filebuf\< \_CharT, \_Traits \>::int\_type std::basic\_filebuf\< \_CharT, \_Traits \>::underflow ()` [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 from std::basic\_streambuf\< \_CharT, \_Traits \>.**

**References std::ios\_base::in.**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_filebuf\< \_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 from std::basic\_streambuf\< \_CharT, \_Traits \>.**

**References std::ios\_base::in.**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_filebuf\< \_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 from std::basic\_streambuf\< \_CharT, \_Traits \>.**

**References std::ios\_base::app, std::min(), and std::ios\_base::out.**

## Member Data Documentation

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

**Pointer to the beginning of internal buffer.**

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

**Current locale setting.**

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

### template\<typename \_CharT , typename \_Traits \> size\_t std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_buf\_size` [protected]`

**Actual size of internal buffer. This number is equal to the size of the put area + 1 position, reserved for the overflow char of a full area.**

### template\<typename \_CharT , typename \_Traits \> char\* std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_ext\_buf` [protected]`

**Buffer for external characters. Used for input when codecvt::always\_noconv() == false. When valid, this corresponds to eback().**

### template\<typename \_CharT , typename \_Traits \> streamsize std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_ext\_buf\_size` [protected]`

**Size of buffer held by \_M\_ext\_buf.**

### template\<typename \_CharT , typename \_Traits \> const char\* std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_ext\_next` [protected]`

**Pointers into the buffer held by \_M\_ext\_buf that delimit a subsequence of bytes that have been read but not yet converted. When valid, \_M\_ext\_next corresponds to egptr().**

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

**Start of get area.**

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

**Current read area.**

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

**End of get area.**

### template\<typename \_CharT , typename \_Traits \> ios\_base::openmode std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_mode` [protected]`

**Place to stash in \|\| out \|\| in \| out settings for current filebuf.**

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

**Start of put area.**

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

**Current put area.**

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

**End of put area.**

### template\<typename \_CharT , typename \_Traits \> char\_type std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_pback` [protected]`

**Necessary bits for putback buffer management.**

**Note**

**pbacks of over one character are not currently supported.**

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

**Necessary bits for putback buffer management.**

**Note**

**pbacks of over one character are not currently supported.**

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

**Necessary bits for putback buffer management.**

**Note**

**pbacks of over one character are not currently supported.**

### template\<typename \_CharT , typename \_Traits \> bool std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_pback\_init` [protected]`

**Necessary bits for putback buffer management.**

**Note**

**pbacks of over one character are not currently supported.**

### template\<typename \_CharT , typename \_Traits \> bool std::basic\_filebuf\< \_CharT, \_Traits \>::\_M\_reading` [protected]`

**\_M\_reading == false && \_M\_writing == false for uncommitted mode; \_M\_reading == true for read mode; \_M\_writing == true for write mode;**

**NB: \_M\_reading == true && \_M\_writing == true is unused.**

## Author

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