cppdraft_translate/cppdraft/stringbuf.md

[stringbuf]

# 31 Input/output library [[input.output]](./#input.output)

## 31.8 String-based streams [[string.streams]](string.streams#stringbuf)

### 31.8.2 Class template basic_stringbuf [stringbuf]

#### [31.8.2.1](#general) General [[stringbuf.general]](stringbuf.general)

[🔗](#lib:basic_stringbuf)

namespace std {template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>class basic_stringbuf : public basic_streambuf<charT, traits> {public:using char_type = charT; using int_type = typename traits::int_type; using pos_type = typename traits::pos_type; using off_type = typename traits::off_type; using traits_type = traits; using allocator_type = Allocator; // [[stringbuf.cons]](#cons "31.8.2.2 Constructors"), constructors basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}explicit basic_stringbuf(ios_base::openmode which); explicit basic_stringbuf(const basic_string<charT, traits, Allocator>& s,
 ios_base::openmode which = ios_base::in | ios_base::out); explicit basic_stringbuf(const Allocator& a): basic_stringbuf(ios_base::in | ios_base::out, a) {} basic_stringbuf(ios_base::openmode which, const Allocator& a); explicit basic_stringbuf( basic_string<charT, traits, Allocator>&& s,
 ios_base::openmode which = ios_base::in | ios_base::out); template<class SAlloc> basic_stringbuf(const basic_string<charT, traits, SAlloc>& s, const Allocator& a): basic_stringbuf(s, ios_base::in | ios_base::out, a) {}template<class SAlloc> basic_stringbuf(const basic_string<charT, traits, SAlloc>& s,
 ios_base::openmode which, const Allocator& a); template<class SAlloc>explicit basic_stringbuf(const basic_string<charT, traits, SAlloc>& s,
 ios_base::openmode which = ios_base::in | ios_base::out); template<class T>explicit basic_stringbuf(const T& t,
 ios_base::openmode which = ios_base::in | ios_base::out); template<class T> basic_stringbuf(const T& t, const Allocator& a); template<class T> basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
 basic_stringbuf(const basic_stringbuf&) = delete;
 basic_stringbuf(basic_stringbuf&& rhs);
 basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a); // [[stringbuf.assign]](#assign "31.8.2.3 Assignment and swap"), assignment and swap basic_stringbuf& operator=(const basic_stringbuf&) = delete;
 basic_stringbuf& operator=(basic_stringbuf&& rhs); void swap(basic_stringbuf& rhs) noexcept(*see below*); // [[stringbuf.members]](#members "31.8.2.4 Member functions"), getters and setters allocator_type get_allocator() const noexcept;

 basic_string<charT, traits, Allocator> str() const &; template<class SAlloc> basic_string<charT,traits,SAlloc> str(const SAlloc& sa) const;
 basic_string<charT, traits, Allocator> str() &&;
 basic_string_view<charT, traits> view() const noexcept; void str(const basic_string<charT, traits, Allocator>& s); template<class SAlloc>void str(const basic_string<charT, traits, SAlloc>& s); void str(basic_string<charT, traits, Allocator>&& s); template<class T>void str(const T& t); protected:// [[stringbuf.virtuals]](#virtuals "31.8.2.5 Overridden virtual functions"), overridden virtual functions int_type underflow() override;
 int_type pbackfail(int_type c = traits::eof()) override;
 int_type overflow (int_type c = traits::eof()) override;
 basic_streambuf<charT, traits>* setbuf(charT*, streamsize) override;

 pos_type seekoff(off_type off, ios_base::seekdir way,
 ios_base::openmode which = ios_base::in | ios_base::out) override;
 pos_type seekpos(pos_type sp,
 ios_base::openmode which = ios_base::in | ios_base::out) override; private: ios_base::openmode *mode*; // *exposition only* basic_string<charT, traits, Allocator> *buf*; // *exposition only*void *init-buf-ptrs*(); // *exposition only*};}

[1](#general-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8113)

The classbasic_stringbuf is derived frombasic_streambuf to associate possibly the input sequence and possibly
the output sequence with a sequence of arbitrary[*characters*](#def:characters)[.](#general-1.sentence-1)

The sequence can be initialized from, or made available as, an object of classbasic_string[.](#general-1.sentence-2)

[2](#general-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8124)

For the sake of exposition,
the maintained data and internal pointer initialization is presented here as:

- [(2.1)](#general-2.1)

  ios_base​::​openmode *mode*, has in set if the input sequence can be read, and out set if the output sequence can be written[.](#general-2.1.sentence-1)

- [(2.2)](#general-2.2)

  basic_string<charT, traits, Allocator> *buf* contains the underlying character sequence[.](#general-2.2.sentence-1)

- [(2.3)](#general-2.3)

  *init-buf-ptrs*() sets the base class'
 get area ([[streambuf.get.area]](streambuf.get.area "31.6.3.4.2 Get area access")) and
 put area ([[streambuf.put.area]](streambuf.put.area "31.6.3.4.3 Put area access")) pointers
 after initializing, moving from, or assigning to *buf* accordingly[.](#general-2.3.sentence-1)

#### [31.8.2.2](#cons) Constructors [[stringbuf.cons]](stringbuf.cons)

[🔗](#lib:basic_stringbuf,constructor)

`explicit basic_stringbuf(ios_base::openmode which);
`

[1](#cons-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8150)

*Effects*: Initializes the base class withbasic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")), and*mode* with which[.](#cons-1.sentence-1)

It isimplementation-defined
whether the sequence pointers
(eback(), gptr(), egptr(),pbase(), pptr(), epptr())
are initialized to null pointers[.](#cons-1.sentence-2)

[2](#cons-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8163)

*Postconditions*: str().empty() is true[.](#cons-2.sentence-1)

[🔗](#lib:basic_stringbuf,constructor_)

`explicit basic_stringbuf(
  const basic_string<charT, traits, Allocator>& s,
  ios_base::openmode which = ios_base::in | ios_base::out);
`

[3](#cons-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8176)

*Effects*: Initializes the base class withbasic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")),*mode* with which, and*buf* with s,
then calls *init-buf-ptrs*()[.](#cons-3.sentence-1)

[🔗](#lib:basic_stringbuf,constructor__)

`basic_stringbuf(ios_base::openmode which, const Allocator& a);
`

[4](#cons-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8191)

*Effects*: Initializes the base class withbasic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")),*mode* with which, and*buf* with a,
then calls *init-buf-ptrs*()[.](#cons-4.sentence-1)

[5](#cons-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8199)

*Postconditions*: str().empty() is true[.](#cons-5.sentence-1)

[🔗](#lib:basic_stringbuf,constructor___)

`explicit basic_stringbuf(
  basic_string<charT, traits, Allocator>&& s,
  ios_base::openmode which = ios_base::in | ios_base::out);
`

[6](#cons-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8212)

*Effects*: Initializes the base class with basic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")),*mode* with which, and*buf* with std​::​move(s),
then calls *init-buf-ptrs*()[.](#cons-6.sentence-1)

[🔗](#lib:basic_stringbuf,constructor____)

`template<class SAlloc>
  basic_stringbuf(
    const basic_string<charT, traits, SAlloc>& s,
    ios_base::openmode which, const Allocator& a);
`

[7](#cons-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8229)

*Effects*: Initializes the base class with basic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")),*mode* with which, and*buf* with {s,a},
then calls *init-buf-ptrs*()[.](#cons-7.sentence-1)

[🔗](#lib:basic_stringbuf,constructor_____)

`template<class SAlloc>
  explicit basic_stringbuf(
    const basic_string<charT, traits, SAlloc>& s,
    ios_base::openmode which = ios_base::in | ios_base::out);
`

[8](#cons-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8246)

*Constraints*: is_same_v<SAlloc, Allocator> is false[.](#cons-8.sentence-1)

[9](#cons-9)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8250)

*Effects*: Initializes the base class with basic_streambuf() ([[streambuf.cons]](streambuf.cons "31.6.3.2 Constructors")),*mode* with which, and*buf* with s,
then calls *init-buf-ptrs*()[.](#cons-9.sentence-1)

[🔗](#lib:basic_stringbuf,constructor______)

`template<class T>
  explicit basic_stringbuf(const T& t, ios_base::openmode which = ios_base::in | ios_base::out);
template<class T>
  basic_stringbuf(const T& t, const Allocator& a);
template<class T>
  basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
`

[10](#cons-10)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8269)

Let which be ios_base​::​in | ios_base​::​out for the overload with no parameter which, anda be Allocator() for the overload with no parameter a[.](#cons-10.sentence-1)

[11](#cons-11)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8274)

*Constraints*: is_convertible_v<const T&, basic_string_view<charT, traits>> is true[.](#cons-11.sentence-1)

[12](#cons-12)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8279)

*Effects*: Creates a variable sv as if bybasic_string_view<charT, traits> sv = t,
then value-initializes the base class,
initializes *mode* with which, and
direct-non-list-initializes *buf* with sv, a,
then calls *init-buf-ptrs*()[.](#cons-12.sentence-1)

[🔗](#lib:basic_stringbuf,constructor_______)

`basic_stringbuf(basic_stringbuf&& rhs);
basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
`

[13](#cons-13)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8296)

*Effects*: Copy constructs the base class from rhs and
initializes *mode* with rhs.mode[.](#cons-13.sentence-1)

In the first form buf is initialized
from std​::​move(rhs).str()[.](#cons-13.sentence-2)

In the second form *buf* is initialized
from {std​::​move(rhs).str(), a}[.](#cons-13.sentence-3)

It isimplementation-defined whether the sequence pointers in *this (eback(), gptr(), egptr(),pbase(), pptr(), epptr()) obtain
the values which rhs had[.](#cons-13.sentence-4)

[14](#cons-14)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8311)

*Postconditions*: Let rhs_p refer to the state ofrhs just prior to this construction and let rhs_a refer to the state of rhs just after this construction[.](#cons-14.sentence-1)

- [(14.1)](#cons-14.1)

str() == rhs_p.str()

- [(14.2)](#cons-14.2)

gptr() - eback() == rhs_p.gptr() - rhs_p.eback()

- [(14.3)](#cons-14.3)

egptr() - eback() == rhs_p.egptr() - rhs_p.eback()

- [(14.4)](#cons-14.4)

pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()

- [(14.5)](#cons-14.5)

epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()

- [(14.6)](#cons-14.6)

if (eback()) eback() != rhs_a.eback()

- [(14.7)](#cons-14.7)

if (gptr()) gptr() != rhs_a.gptr()

- [(14.8)](#cons-14.8)

if (egptr()) egptr() != rhs_a.egptr()

- [(14.9)](#cons-14.9)

if (pbase()) pbase() != rhs_a.pbase()

- [(14.10)](#cons-14.10)

if (pptr()) pptr() != rhs_a.pptr()

- [(14.11)](#cons-14.11)

if (epptr()) epptr() != rhs_a.epptr()

- [(14.12)](#cons-14.12)

getloc() == rhs_p.getloc()

- [(14.13)](#cons-14.13)

rhs is empty but usable,
 as if std​::​move(rhs).str() was called.

#### [31.8.2.3](#assign) Assignment and swap [[stringbuf.assign]](stringbuf.assign)

[🔗](#lib:operator=,basic_stringbuf)

`basic_stringbuf& operator=(basic_stringbuf&& rhs);
`

[1](#assign-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8343)

*Effects*: After the move assignment *this has the observable state it would
have had if it had been move constructed from rhs (see [[stringbuf.cons]](#cons "31.8.2.2 Constructors"))[.](#assign-1.sentence-1)

[2](#assign-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8348)

*Returns*: *this[.](#assign-2.sentence-1)

[🔗](#lib:swap,basic_stringbuf)

`void swap(basic_stringbuf& rhs) noexcept(see below);
`

[3](#assign-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8359)

*Preconditions*: allocator_traits<Allocator>​::​propagate_on_container_swap​::​value is true orget_allocator() == rhs.get_allocator() is true[.](#assign-3.sentence-1)

[4](#assign-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8365)

*Effects*: Exchanges the state of *this and rhs[.](#assign-4.sentence-1)

[5](#assign-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8370)

*Remarks*: The exception specification is equivalent to:  

allocator_traits<Allocator>​::​propagate_on_container_swap​::​value ||  

allocator_traits<Allocator>​::​is_always_equal​::​value

[🔗](#lib:swap,basic_stringbuf_)

`template<class charT, class traits, class Allocator>
  void swap(basic_stringbuf<charT, traits, Allocator>& x,
            basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
`

[6](#assign-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8385)

*Effects*: Equivalent to x.swap(y)[.](#assign-6.sentence-1)

#### [31.8.2.4](#members) Member functions [[stringbuf.members]](stringbuf.members)

[1](#members-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8392)

The member functions getting the underlying character sequence
all refer to a high_mark value,
where high_mark represents the position
one past the highest initialized character in the buffer[.](#members-1.sentence-1)

Characters can be initialized by writing to the stream,
by constructing the basic_stringbuf passing a basic_string argument, or
by calling one of the str member functions
passing a basic_string as an argument[.](#members-1.sentence-2)

In the latter case, all characters initialized prior to the call
are now considered uninitialized
(except for those characters re-initialized by the new basic_string)[.](#members-1.sentence-3)

[🔗](#members-itemdecl:1)

`void init-buf-ptrs();
`

[2](#members-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8411)

*Effects*: Initializes the input and output sequences from *buf* according to *mode*[.](#members-2.sentence-1)

[3](#members-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8416)

*Postconditions*: 

- [(3.1)](#members-3.1)

  If ios_base​::​out is set in *mode*, pbase() points to *buf*.front() and epptr() >= pbase() + *buf*.size() is true;
  * [(3.1.1)](#members-3.1.1)

in addition, if ios_base​::​ate is set in *mode*, pptr() == pbase() + *buf*.size() is true,

  * [(3.1.2)](#members-3.1.2)

otherwise pptr() == pbase() is true[.](#members-3.1.sentence-1)

- [(3.2)](#members-3.2)

  If ios_base​::​in is set in *mode*, eback() points to *buf*.front(), and (gptr() == eback() && egptr() == eback() + *buf*.size()) is true[.](#members-3.2.sentence-1)

[4](#members-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8433)

[*Note [1](#members-note-1)*:

For efficiency reasons,
stream buffer operations can violate invariants of *buf* while it is held encapsulated in the basic_stringbuf,
e.g., by writing to characters in the range
[*buf*.data() + *buf*.size(), *buf*.data() + *buf*.capacity())[.](#members-4.sentence-1)

All operations retrieving a basic_string from buf ensure that the basic_string invariants hold on the returned value[.](#members-4.sentence-2)

— *end note*]

[🔗](#lib:get_allocator,basic_stringbuf)

`allocator_type get_allocator() const noexcept;
`

[5](#members-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8451)

*Returns*: *buf*.get_allocator()[.](#members-5.sentence-1)

[🔗](#lib:str,basic_stringbuf)

`basic_string<charT, traits, Allocator> str() const &;
`

[6](#members-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8462)

*Effects*: Equivalent to:return basic_string<charT, traits, Allocator>(view(), get_allocator());

[🔗](#lib:str,basic_stringbuf_)

`template<class SAlloc>
  basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
`

[7](#members-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8477)

*Constraints*: SAlloc is a type that
qualifies as an allocator ([[container.reqmts]](container.reqmts "23.2.2.2 Container requirements"))[.](#members-7.sentence-1)

[8](#members-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8482)

*Effects*: Equivalent to:return basic_string<charT, traits, SAlloc>(view(), sa);

[🔗](#members-itemdecl:5)

`basic_string<charT, traits, Allocator> str() &&;
`

[9](#members-9)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8495)

*Postconditions*: The underlying character sequence buf is empty andpbase(), pptr(), epptr(), eback(),gptr(), and egptr() are initialized as if by calling *init-buf-ptrs*() with an empty buf[.](#members-9.sentence-1)

[10](#members-10)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8503)

*Returns*: A basic_string<charT, traits, Allocator> object
move constructed from
the basic_stringbuf's underlying character sequence in buf[.](#members-10.sentence-1)

This can be achieved by first adjusting buf to have
the same content as view()[.](#members-10.sentence-2)

[🔗](#lib:view,basic_stringbuf)

`basic_string_view<charT, traits> view() const noexcept;
`

[11](#members-11)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8518)

Let sv be basic_string_view<charT, traits>[.](#members-11.sentence-1)

[12](#members-12)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8521)

*Returns*: A sv object referring to
the basic_stringbuf's underlying character sequence in buf:

- [(12.1)](#members-12.1)

  If ios_base​::​out is set in *mode*,
 then sv(pbase(), high_mark - pbase()) is returned[.](#members-12.1.sentence-1)

- [(12.2)](#members-12.2)

  Otherwise, if ios_base​::​in is set in *mode*,
 then sv(eback(), egptr() - eback()) is returned[.](#members-12.2.sentence-1)

- [(12.3)](#members-12.3)

  Otherwise, sv() is returned[.](#members-12.3.sentence-1)

[13](#members-13)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8533)

[*Note [2](#members-note-2)*:

Using the returned sv object after
destruction or invalidation of the character sequence underlying *this is undefined behavior, unless sv.empty() is true[.](#members-13.sentence-1)

— *end note*]

[🔗](#lib:str,basic_stringbuf__)

`void str(const basic_string<charT, traits, Allocator>& s);
`

[14](#members-14)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8547)

*Effects*: Equivalent to:*buf* = s;*init-buf-ptrs*();

[🔗](#lib:str,basic_stringbuf___)

`template<class SAlloc>
  void str(const basic_string<charT, traits, SAlloc>& s);
`

[15](#members-15)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8563)

*Constraints*: is_same_v<SAlloc, Allocator> is false[.](#members-15.sentence-1)

[16](#members-16)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8567)

*Effects*: Equivalent to:*buf* = s;*init-buf-ptrs*();

[🔗](#lib:str,basic_stringbuf____)

`void str(basic_string<charT, traits, Allocator>&& s);
`

[17](#members-17)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8582)

*Effects*: Equivalent to:*buf* = std::move(s);*init-buf-ptrs*();

[🔗](#lib:str,basic_stringbuf_____)

`template<class T>
  void str(const T& t);
`

[18](#members-18)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8598)

*Constraints*: is_convertible_v<const T&, basic_string_view<charT, traits>> is true[.](#members-18.sentence-1)

[19](#members-19)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8603)

*Effects*: Equivalent to:basic_string_view<charT, traits> sv = t;*buf* = sv;*init-buf-ptrs*();

#### [31.8.2.5](#virtuals) Overridden virtual functions [[stringbuf.virtuals]](stringbuf.virtuals)

[🔗](#lib:underflow,basic_stringbuf)

`int_type underflow() override;
`

[1](#virtuals-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8621)

*Returns*: If the input sequence has a read position available,
returnstraits​::​to_int_type(*gptr())[.](#virtuals-1.sentence-1)

Otherwise, returnstraits​::​eof()[.](#virtuals-1.sentence-2)

Any character in the underlying buffer which has been initialized is considered
to be part of the input sequence[.](#virtuals-1.sentence-3)

[🔗](#lib:pbackfail,basic_stringbuf)

`int_type pbackfail(int_type c = traits::eof()) override;
`

[2](#virtuals-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8638)

*Effects*: Puts back the character designated by c to the input
sequence, if possible, in one of three ways:

- [(2.1)](#virtuals-2.1)

  Iftraits​::​eq_int_type(c, traits​::​eof()) returnsfalse and
if the input sequence has a putback position available, and
iftraits​::​eq(to_char_type(c), gptr()[-1]) returnstrue,
assignsgptr() - 1 togptr()[.](#virtuals-2.1.sentence-1)
  Returns:c[.](#virtuals-2.1.sentence-2)

- [(2.2)](#virtuals-2.2)

  Iftraits​::​eq_int_type(c, traits​::​eof()) returnsfalse and if the input sequence
has a putback position available, and
if *mode*&ios_base​::​out is
nonzero,
assigns c to*--gptr()[.](#virtuals-2.2.sentence-1)
  Returns:c[.](#virtuals-2.2.sentence-2)

- [(2.3)](#virtuals-2.3)

  Iftraits​::​eq_int_type(c, traits​::​eof()) returnstrue and if the input sequence has a putback position available,
assignsgptr() - 1 togptr()[.](#virtuals-2.3.sentence-1)
  Returns:traits​::​not_eof(c)[.](#virtuals-2.3.sentence-2)

[3](#virtuals-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8692)

*Returns*: As specified above, ortraits​::​eof() to indicate failure[.](#virtuals-3.sentence-1)

[4](#virtuals-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8698)

*Remarks*: If the function can succeed in more than one of these ways, it is
unspecified which way is chosen[.](#virtuals-4.sentence-1)

[🔗](#lib:overflow,basic_stringbuf)

`int_type overflow(int_type c = traits::eof()) override;
`

[5](#virtuals-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8711)

*Effects*: Appends the character designated by c to the output
sequence, if possible, in one of two ways:

- [(5.1)](#virtuals-5.1)

  Iftraits​::​eq_int_type(c, traits​::​eof()) returnsfalse and if either
the output sequence has a write position available or
the function makes a write position available
(as described below),
the function callssputc(c)[.](#virtuals-5.1.sentence-1)
  Signals success by returning c[.](#virtuals-5.1.sentence-2)

- [(5.2)](#virtuals-5.2)

  Iftraits​::​eq_int_type(c, traits​::​eof()) returnstrue,
there is no character to append[.](#virtuals-5.2.sentence-1)
  Signals success by returning a value other thantraits​::​eof()[.](#virtuals-5.2.sentence-2)

[6](#virtuals-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8741)

*Returns*: As specified above, ortraits​::​eof() to indicate failure[.](#virtuals-6.sentence-1)

[7](#virtuals-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8747)

*Remarks*: The function can alter the number of write positions available as a
result of any call[.](#virtuals-7.sentence-1)

[8](#virtuals-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8752)

The function can make a write position available only ifios_base​::​out is set in *mode*[.](#virtuals-8.sentence-1)

To make a write position available,
the function reallocates (or initially allocates) an array object
with a sufficient number of elements to hold
the current array object (if any), plus
at least
one additional write position[.](#virtuals-8.sentence-2)

If ios_base​::​in is set in *mode*,
the function alters the read end pointeregptr() to point just past the new write position[.](#virtuals-8.sentence-3)

[🔗](#lib:seekoff,basic_stringbuf)

`pos_type seekoff(off_type off, ios_base::seekdir way,
                 ios_base::openmode which
                   = ios_base::in | ios_base::out) override;
`

[9](#virtuals-9)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8775)

*Effects*: Alters the stream position within one of the
controlled sequences, if possible, as indicated in Table [144](#tab:stringbuf.seekoff.pos "Table 144: seekoff positioning")[.](#virtuals-9.sentence-1)

Table [144](#tab:stringbuf.seekoff.pos) — seekoff positioning [[tab:stringbuf.seekoff.pos]](./tab:stringbuf.seekoff.pos)  

| [🔗](#tab:stringbuf.seekoff.pos-row-1)<br>**Conditions** | **Result** |
| --- | --- |
| [🔗](#tab:stringbuf.seekoff.pos-row-2)<br>ios_base​::​in is set in which | positions the input sequence |
| [🔗](#tab:stringbuf.seekoff.pos-row-3)<br>ios_base​::​out is set in which | positions the output sequence |
| [🔗](#tab:stringbuf.seekoff.pos-row-4)<br>both ios_base​::​in and ios_base​::​out are set in which and either   way == ios_base​::​beg or   way == ios_base​::​end | positions both the input and the output sequences |
| [🔗](#tab:stringbuf.seekoff.pos-row-5)<br>Otherwise | the positioning operation fails[.](#tab:stringbuf.seekoff.pos-row-5-column-2-sentence-1) |

[10](#virtuals-10)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8795)

For a sequence to be positioned,
the function determines newoff as indicated in
Table [145](#tab:stringbuf.seekoff.newoff "Table 145: newoff values")[.](#virtuals-10.sentence-1)

If the sequence's next pointer
(eithergptr() orpptr())
is a null pointer and newoff is nonzero,
the positioning operation fails[.](#virtuals-10.sentence-2)

Table [145](#tab:stringbuf.seekoff.newoff) — newoff values [[tab:stringbuf.seekoff.newoff]](./tab:stringbuf.seekoff.newoff)  

| [🔗](#tab:stringbuf.seekoff.newoff-row-1)<br>**Condition** | **newoff Value** |
| --- | --- |
| [🔗](#tab:stringbuf.seekoff.newoff-row-2)<br>way == ios_base​::​beg | 0 |
| [🔗](#tab:stringbuf.seekoff.newoff-row-3)<br>way == ios_base​::​cur | the next pointer minus the beginning pointer (xnext - xbeg)[.](#tab:stringbuf.seekoff.newoff-row-3-column-2-sentence-1) |
| [🔗](#tab:stringbuf.seekoff.newoff-row-4)<br>way == ios_base​::​end | the high mark pointer minus the beginning pointer (high_mark - xbeg)[.](#tab:stringbuf.seekoff.newoff-row-4-column-2-sentence-1) |

[11](#virtuals-11)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8817)

If(newoff + off) < 0,
or if newoff + off refers to an uninitialized
character ([[stringbuf.members]](#members "31.8.2.4 Member functions")),
the positioning operation fails[.](#virtuals-11.sentence-1)

Otherwise, the function assignsxbeg + newoff + off to the next pointer xnext[.](#virtuals-11.sentence-2)

[12](#virtuals-12)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8827)

*Returns*: pos_type(newoff),
constructed from the resultant offset newoff (of typeoff_type),
that stores the resultant stream position, if possible[.](#virtuals-12.sentence-1)

If the positioning operation fails, or
if the constructed object cannot represent the resultant stream position,
the return value ispos_type(off_type(-1))[.](#virtuals-12.sentence-2)

[🔗](#lib:seekpos,basic_stringbuf)

`pos_type seekpos(pos_type sp,
                 ios_base::openmode which
                   = ios_base::in | ios_base::out) override;
`

[13](#virtuals-13)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8848)

*Effects*: Equivalent to seekoff(off_type(sp), ios_base​::​beg, which)[.](#virtuals-13.sentence-1)

[14](#virtuals-14)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8852)

*Returns*: sp to indicate success, orpos_type(off_type(-1)) to indicate failure[.](#virtuals-14.sentence-1)

[🔗](#lib:setbuf,basic_streambuf)

`basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n) override;
`

[15](#virtuals-15)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8866)

*Effects*: implementation-defined,
except thatsetbuf(0, 0) has no effect[.](#virtuals-15.sentence-1)

[16](#virtuals-16)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/iostreams.tex#L8873)

*Returns*: this[.](#virtuals-16.sentence-1)