--- name: "__gnu_cxx::enc_filebuf" section: "3" platform: "linux" package: "gcc" version: "16.2.1+r23+gd564253eb6c8-1" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/__gnu_cxx::enc_filebuf" --- # \_\_gnu\_cxx::enc\_filebuf(3) class enc\_filebuf. ## NAME \_\_gnu\_cxx::enc\_filebuf\< \_CharT \> - class enc\_filebuf. ## SYNOPSIS \#include \ Inherits **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**. ### 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\_type::state\_type **state\_type**\ typedef **encoding\_char\_traits**\< \_CharT \> **traits\_type**\ ### Public Member Functions **enc\_filebuf** (state\_type &\_\_state)\ \_\_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. \_\_filebuf\_type \* **open** (const char \*\_\_s, ios\_base::openmode \_\_mode)\ Opens an external file. 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=**encoding\_char\_traits**\< \_CharT \>::eof())\ Consumes data from the buffer; writes to the controlled sequence. virtual int\_type **pbackfail** (int\_type \_\_c=**encoding\_char\_traits**\< \_CharT \>::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**\ ## Detailed Description ### template\ class \_\_gnu\_cxx::enc\_filebuf\< \_CharT \>"class enc\_filebuf. ## Member Function Documentation ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_create\_pback () \[inline\], \[protected\], \[inherited\] Initializes pback buffers, and moves normal buffers to safety. Assumptions: \_M\_in\_cur has already been moved back ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_destroy\_pback () \[inline\], \[protected\], \[inherited\] Deactivates pback buffer contents, and restores normal buffer. Assumptions: The pback buffer has only moved forward. ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_set\_buffer (streamsize \_\_off) \[inline\], \[protected\], \[inherited\] 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. Referenced by **seekpos()**, and **setbuf()**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::close () \[inherited\] 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. ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### void std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### locale std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::imbue (const locale & \_\_loc) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. ### streamsize std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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(). ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::is\_open () const \[inline\], \[nodiscard\], \[inherited\] Returns true if the external file is open. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::open (const char \* \_\_s, ios\_base::openmode \_\_mode) \[inherited\] 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 | +---------------------------------------------------------+ ``` ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::overflow (int\_type \_\_c = \_Traits::eof()) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. References **\_M\_ext\_buf**, **\_M\_ext\_next**, and **eback()**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pbackfail (int\_type \_\_c = \_Traits::eof()) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. References **\_M\_ext\_buf**, **\_M\_ext\_next**, and **eback()**. ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### void std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### char\_type \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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 ### locale std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pubimbue (const locale & \_\_loc) \[inline\], \[inherited\] Entry point for imbue(). **Parameters** *\_\_loc* The new locale. **Returns** The previous locale. Calls the derived imbue(\_\_loc). ### pos\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### pos\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### basic\_streambuf \* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### int std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pubsync () \[inline\], \[inherited\] Calls virtual sync function. ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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(). ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pos\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::seekoff (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode = ios\_base::in \| ios\_base::out) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. References **gptr()**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pos\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::seekpos (pos\_type \_\_pos, ios\_base::openmode \_\_mode = ios\_base::in \| ios\_base::out) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. References **\_M\_reading**, and **\_M\_set\_buffer()**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_streambuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::setbuf (char\_type \* \_\_s, streamsize \_\_n) \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>**. References **\_M\_reading**, and **\_M\_set\_buffer()**. ### void std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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() ### void std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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() ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### streamsize std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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. ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::showmanyc () \[protected\], \[virtual\], \[inherited\] 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, encoding\_char\_traits\< \_CharT \> \>.** ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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()**.** ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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***.** ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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)**.** ### streamsize std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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.** ### int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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***.** ### int std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::sync () \[protected\], \[virtual\], \[inherited\] **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, encoding\_char\_traits\< \_CharT \> \>.** ### virtual int\_type std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::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.** ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::underflow () \[protected\], \[virtual\], \[inherited\] **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, encoding\_char\_traits\< \_CharT \> \>.** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::xsgetn (char\_type \* \_\_s, streamsize \_\_n) \[protected\], \[virtual\], \[inherited\] **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, encoding\_char\_traits\< \_CharT \> \>.** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::xsputn (const char\_type \* \_\_s, streamsize \_\_n) \[protected\], \[virtual\], \[inherited\] **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, encoding\_char\_traits\< \_CharT \> \>.** ## Member Data Documentation ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_buf \[protected\], \[inherited\] **Pointer to the beginning of internal buffer.** ### locale std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_buf\_locale \[protected\], \[inherited\] **Current locale setting.** ### size\_t std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_buf\_size \[protected\], \[inherited\] **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.** ### char\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_buf \[protected\], \[inherited\] **Buffer for external characters. Used for input when codecvt::always\_noconv() == false. When valid, this corresponds to eback().** **Referenced by overflow(), and pbackfail().** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_buf\_size \[protected\], \[inherited\] **Size of buffer held by \_M\_ext\_buf.** ### const char\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_next \[protected\], \[inherited\] **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().** **Referenced by overflow(), and pbackfail().** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_in\_beg \[protected\], \[inherited\] **Start of get area.** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_in\_cur \[protected\], \[inherited\] **Current read area.** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_in\_end \[protected\], \[inherited\] **End of get area.** ### ios\_base::openmode std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_mode \[protected\], \[inherited\] **Place to stash in \|\| out \|\| in \| out settings for current filebuf.** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_out\_beg \[protected\], \[inherited\] **Start of put area.** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_out\_cur \[protected\], \[inherited\] **Current put area.** ### char\_type\* std::basic\_streambuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_out\_end \[protected\], \[inherited\] **End of put area.** ### char\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback \[protected\], \[inherited\] **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_cur\_save \[protected\], \[inherited\] **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_end\_save \[protected\], \[inherited\] **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_init \[protected\], \[inherited\] **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_reading \[protected\], \[inherited\] **\_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.** **Referenced by seekpos(), and setbuf().** ## Author **Generated automatically by Doxygen for libstdc++ from the source code.**