Init

2025-10-25 03:02:53 +03:00
commit 043225d523
3416 changed files with 681196 additions and 0 deletions
--- a/cppdraft/stringbuf.md
+++ b/cppdraft/stringbuf.md
@@ -0,0 +1,802 @@
+[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)