namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_stringbuf; using stringbuf = basic_stringbuf<char>; using wstringbuf = basic_stringbuf<wchar_t>; template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_istringstream; using istringstream = basic_istringstream<char>; using wistringstream = basic_istringstream<wchar_t>; template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_ostringstream; using ostringstream = basic_ostringstream<char>; using wostringstream = basic_ostringstream<wchar_t>; template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_stringstream; using stringstream = basic_stringstream<char>; using wstringstream = basic_stringstream<wchar_t>; }
Заголовок <sstream> определяет четыре шаблона классов и восемь типов, которые связывают буферы потока с объектами класса basic_string, как описано в [string.classes].
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], constructors explicit basic_stringbuf( ios_base::openmode which = ios_base::in | ios_base::out); explicit basic_stringbuf( const basic_string<charT, traits, Allocator>& str, ios_base::openmode which = ios_base::in | ios_base::out); basic_stringbuf(const basic_stringbuf& rhs) = delete; basic_stringbuf(basic_stringbuf&& rhs); // [stringbuf.assign], assign and swap basic_stringbuf& operator=(const basic_stringbuf& rhs) = delete; basic_stringbuf& operator=(basic_stringbuf&& rhs); void swap(basic_stringbuf& rhs); // [stringbuf.members], get and set basic_string<charT, traits, Allocator> str() const; void str(const basic_string<charT, traits, Allocator>& s); protected: // [stringbuf.virtuals], 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 }; template <class charT, class traits, class Allocator> void swap(basic_stringbuf<charT, traits, Allocator>& x, basic_stringbuf<charT, traits, Allocator>& y); }
Класс basic_stringbuf является производным от, basic_streambuf чтобы связать, возможно, входную последовательность и, возможно, выходную последовательность с произвольной последовательностью characters. Последовательность может быть инициализирована или сделана доступной как объект класса basic_string.
Для демонстрации поддерживаемые данные представлены здесь как:
ios_base::openmode mode, in установлен, если входная последовательность может быть прочитана, и out установлена, если выходная последовательность может быть записана.
explicit basic_stringbuf(
ios_base::openmode which = ios_base::in | ios_base::out);
Effects: Создает объект класса basic_stringbuf, инициализируя базовый класс с помощью basic_streambuf() ([streambuf.cons]) и инициализируя mode с помощью which.
explicit basic_stringbuf(
const basic_string<charT, traits, Allocator>& s,
ios_base::openmode which = ios_base::in | ios_base::out);
Effects: Создает объект класса basic_stringbuf, инициализируя базовый класс с помощью basic_streambuf() ([streambuf.cons]) и инициализируя mode с помощью which. Потом звонит str(s).
basic_stringbuf(basic_stringbuf&& rhs);
Effects: Переместите конструкции из rvalue rhs. Это определяется реализация ли указатели последовательности в *this (eback(), gptr(), egptr(), pbase(), pptr(), epptr()) получить значение , которые rhs имели. Независимо от того, работают они или нет, *this и rhs ссылаются на отдельные буферы (если они вообще есть) после построения. Также копируются режим openmode, locale и любое другое состояние rhs .
Postconditions: Позвольте rhs_p ссылаться на состояние rhs непосредственно перед этой конструкцией и позвольте rhs_a ссылаться на состояние rhs сразу после этой конструкции.
str() == rhs_p.str()
gptr() - eback() == rhs_p.gptr() - rhs_p.eback()
egptr() - eback() == rhs_p.egptr() - rhs_p.eback()
pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()
epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()
if (eback()) eback() != rhs_a.eback()
if (gptr()) gptr() != rhs_a.gptr()
if (egptr()) egptr() != rhs_a.egptr()
if (pbase()) pbase() != rhs_a.pbase()
if (pptr()) pptr() != rhs_a.pptr()
if (epptr()) epptr() != rhs_a.epptr()
basic_stringbuf& operator=(basic_stringbuf&& rhs);
Effects: После того, как присвоение хода *this приобрело наблюдаемое состояние, оно было бы, если бы оно было построено из rhs (см. [stringbuf.cons]).
void swap(basic_stringbuf& rhs);
template <class charT, class traits, class Allocator>
void swap(basic_stringbuf<charT, traits, Allocator>& x,
basic_stringbuf<charT, traits, Allocator>& y);
basic_string<charT, traits, Allocator> str() const;
Returns: basic_string Объект, содержание которого равна basic_stringbuf базовой последовательности символов. Если basic_stringbuf был создан только в режиме ввода, результат будет basic_string содержать последовательность символов в диапазоне [eback(), egptr()). Если basic_stringbuf был создан с which & ios_base::out ненулевым значением, то результат basic_string содержит последовательность символов в диапазоне [pbase(), high_mark), где high_mark представляет позицию после самого высокого инициализированного символа в буфере. Символы можно инициализировать путем записи в поток, создания с basic_stringbuf помощью a basic_stringили вызова str(basic_string) функции-члена. В случае вызова str(basic_string) функции-члена все символы, инициализированные до вызова, теперь считаются неинициализированными (за исключением тех символов, которые повторно инициализированы новым basic_string). В противном случае basic_stringbuf объект не был создан ни в режиме ввода, ни в режиме вывода, и basic_string возвращается нулевая длина .
void str(const basic_string<charT, traits, Allocator>& s);
Effects: Копирует содержимое s в basic_stringbuf базовую последовательность символов и инициализирует входные и выходные последовательности в соответствии с mode.
Postconditions: Если mode & ios_base::out не ноль, pbase() указывает на первый базовый символ и epptr() >= pbase() + s.size() удерживается; кроме того, если не mode & ios_base::ate равно нулю, то pptr() == pbase() + s.size() имеет место, иначе pptr() == pbase() - нет true. Если не mode & ios_base::in равно нулю, eback() указывает на первый базовый символ, и оба gptr() == eback() и egptr() == eback() + s.size() удерживаются.
int_type underflow() override;
Returns: Если входная последовательность имеет доступную позицию чтения, возвращается traits::to_int_type(*gptr()). В противном случае возвращается traits::eof(). Любой инициализированный символ в нижележащем буфере считается частью входной последовательности.
int_type pbackfail(int_type c = traits::eof()) override;
Effects: Возвращает символ, обозначенный значком, c во входную последовательность, если это возможно, одним из трех способов:
Если traits::eq_int_type(c, traits::eof()) возвращается ,false и если входная последовательность имеет место Putback доступный, и если traits::eq(to_char_type(c), gptr()[-1]) возвращается true, правопреемники gptr() - 1 в gptr().
Возвращает: c.
Если traits::eq_int_type(c, traits::eof()) возвращается ,false и если входная последовательность имеет место Putback доступный, и если не mode & ios_base::out равен нулю, правопреемников c к *--gptr().
Возвращает: c.
Если traits::eq_int_type(c, traits::eof()) возвращается ,true и если входная последовательность имеет место Putback доступный, правопреемники gptr() - 1 к gptr().
Возвращает: traits::not_eof(c).
int_type overflow(int_type c = traits::eof()) override;
Effects: Добавляет символ, обозначенный значком, c к выходной последовательности, если возможно, одним из двух способов:
Если traits::eq_int_type(c, traits::eof()) возвращается, false и если либо выходная последовательность имеет доступную позицию записи, либо функция делает доступной позицию записи (как описано ниже), функция вызывает sputc(c).
Сигнализирует об успехе, возвращаясь c.
Если traits::eq_int_type(c, traits::eof()) возвращается true, нет символа для добавления.
Сигнализирует об успехе, возвращая значение, отличное от traits::eof().
Функция может сделать позицию записи доступной, только если (mode & ios_base::out) != 0. Чтобы сделать позицию записи доступной, функция перераспределяет (или первоначально выделяет) объект массива с достаточным количеством элементов, чтобы удерживать текущий объект массива (если есть), плюс по крайней мере одну дополнительную позицию записи. Если (mode & ios_base::in) != 0, функция изменяет указатель конца чтения так, egptr() чтобы он указывал сразу за новой позицией записи.
pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode which
= ios_base::in | ios_base::out) override;
Effects: Если возможно, изменяет положение потока в одной из управляемых последовательностей, как указано в Табл 115.
Условия | Результат |
(which & ios_base::in) == ios_base::in | позиционирует входную последовательность |
(which & ios_base::out) == ios_base::out | позиционирует выходную последовательность |
(which & (ios_base::in | ios_base::out)) == (ios_base::in) | ios_base::out)) и way == либо, ios_base::beg либо ios_base::end | позиционирует как входную, так и выходную последовательности |
Иначе | операция позиционирования не выполняется. |
Для позиционирования последовательности, если ее следующий указатель (или gptr() или pptr()) является нулевым указателем, а новое смещение не newoff равно нулю, операция позиционирования завершается ошибкой. В противном случае функция определяет, newoff как указано в таблице 116.
Состояние | newoff Ценить |
way == ios_base::beg | 0 |
way == ios_base::cur | следующий указатель минус указатель начала (xnext - xbeg). |
way == ios_base::end | указатель верхней отметки минус указатель начала (high_mark - xbeg). |
Если (newoff + off) < 0или если newoff + off относится к неинициализированному символу ([stringbuf.members]), операция позиционирования завершается ошибкой. В противном случае функция присваивает xbeg + newoff + off следующий указатель xnext.
Returns: pos_type(newoff), построенный из результирующего смещения newoff (типа off_type), в котором, если возможно, сохраняется позиция результирующего потока. Если операция позиционирования завершается неудачно, или если сконструированный объект не может представлять позицию результирующего потока, возвращается значение pos_type(off_type(-1)).
pos_type seekpos(pos_type sp,
ios_base::openmode which
= ios_base::in | ios_base::out) override;
basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n);
namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_istringstream : public basic_istream<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; // [istringstream.cons], constructors explicit basic_istringstream( ios_base::openmode which = ios_base::in); explicit basic_istringstream( const basic_string<charT, traits, Allocator>& str, ios_base::openmode which = ios_base::in); basic_istringstream(const basic_istringstream& rhs) = delete; basic_istringstream(basic_istringstream&& rhs); // [istringstream.assign], assign and swap basic_istringstream& operator=(const basic_istringstream& rhs) = delete; basic_istringstream& operator=(basic_istringstream&& rhs); void swap(basic_istringstream& rhs); // [istringstream.members], members basic_stringbuf<charT, traits, Allocator>* rdbuf() const; basic_string<charT, traits, Allocator> str() const; void str(const basic_string<charT, traits, Allocator>& s); private: basic_stringbuf<charT, traits, Allocator> sb; // exposition only }; template <class charT, class traits, class Allocator> void swap(basic_istringstream<charT, traits, Allocator>& x, basic_istringstream<charT, traits, Allocator>& y); }
Класс basic_istringstream<charT, traits, Allocator> поддерживает чтение объектов класса basic_string<charT, traits, Allocator>. Он использует basic_stringbuf<charT, traits, Allocator> объект для управления связанным хранилищем. Для демонстрации поддерживаемые данные представлены здесь как:
sb, stringbuf объект.
explicit basic_istringstream(ios_base::openmode which = ios_base::in);
Effects: Создает объект класса basic_istringstream<charT, traits>, инициализируя базовый класс с помощью basic_istream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(which | ios_base::in)) ([stringbuf.cons]).
explicit basic_istringstream(
const basic_string<charT, traits, Allocator>& str,
ios_base::openmode which = ios_base::in);
Effects: Создает объект класса basic_istringstream<charT, traits>, инициализируя базовый класс с помощью basic_istream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(str, which | ios_base::in)) ([stringbuf.cons]).
basic_istringstream(basic_istringstream&& rhs);
basic_istringstream& operator=(basic_istringstream&& rhs);
void swap(basic_istringstream& rhs);
Effects: Меняет состояние *this и rhs по вызову basic_istream<charT, traits>::swap(rhs) и sb.swap(rhs.sb).
template <class charT, class traits, class Allocator>
void swap(basic_istringstream<charT, traits, Allocator>& x,
basic_istringstream<charT, traits, Allocator>& y);
basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
basic_string<charT, traits, Allocator> str() const;
void str(const basic_string<charT, traits, Allocator>& s);
namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_ostringstream : public basic_ostream<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; // [ostringstream.cons], constructors explicit basic_ostringstream( ios_base::openmode which = ios_base::out); explicit basic_ostringstream( const basic_string<charT, traits, Allocator>& str, ios_base::openmode which = ios_base::out); basic_ostringstream(const basic_ostringstream& rhs) = delete; basic_ostringstream(basic_ostringstream&& rhs); // [ostringstream.assign], assign and swap basic_ostringstream& operator=(const basic_ostringstream& rhs) = delete; basic_ostringstream& operator=(basic_ostringstream&& rhs); void swap(basic_ostringstream& rhs); // [ostringstream.members], members basic_stringbuf<charT, traits, Allocator>* rdbuf() const; basic_string<charT, traits, Allocator> str() const; void str(const basic_string<charT, traits, Allocator>& s); private: basic_stringbuf<charT, traits, Allocator> sb; // exposition only }; template <class charT, class traits, class Allocator> void swap(basic_ostringstream<charT, traits, Allocator>& x, basic_ostringstream<charT, traits, Allocator>& y); }
Класс basic_ostringstream<charT, traits, Allocator> поддерживает запись объектов класса basic_string<charT, traits, Allocator>. Он использует basic_stringbuf объект для управления связанным хранилищем. Для демонстрации поддерживаемые данные представлены здесь как:
sb, stringbuf объект.
explicit basic_ostringstream(
ios_base::openmode which = ios_base::out);
Effects: Создает объект класса basic_ostringstream, инициализируя базовый класс с помощью basic_ostream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(which | ios_base::out)) ([stringbuf.cons]).
explicit basic_ostringstream(
const basic_string<charT, traits, Allocator>& str,
ios_base::openmode which = ios_base::out);
Effects: Создает объект класса basic_ostringstream<charT, traits>, инициализируя базовый класс с помощью basic_ostream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(str, which | ios_base::out)) ([stringbuf.cons]).
basic_ostringstream(basic_ostringstream&& rhs);
basic_ostringstream& operator=(basic_ostringstream&& rhs);
void swap(basic_ostringstream& rhs);
Effects: Меняет состояние *this и rhs по вызову basic_ostream<charT, traits>::swap(rhs) и sb.swap(rhs.sb).
template <class charT, class traits, class Allocator>
void swap(basic_ostringstream<charT, traits, Allocator>& x,
basic_ostringstream<charT, traits, Allocator>& y);
basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
basic_string<charT, traits, Allocator> str() const;
void str(const basic_string<charT, traits, Allocator>& s);
namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_stringstream : public basic_iostream<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; // [stringstream.cons], constructors explicit basic_stringstream( ios_base::openmode which = ios_base::out | ios_base::in); explicit basic_stringstream( const basic_string<charT, traits, Allocator>& str, ios_base::openmode which = ios_base::out | ios_base::in); basic_stringstream(const basic_stringstream& rhs) = delete; basic_stringstream(basic_stringstream&& rhs); // [stringstream.assign], assign and swap basic_stringstream& operator=(const basic_stringstream& rhs) = delete; basic_stringstream& operator=(basic_stringstream&& rhs); void swap(basic_stringstream& rhs); // [stringstream.members], members basic_stringbuf<charT, traits, Allocator>* rdbuf() const; basic_string<charT, traits, Allocator> str() const; void str(const basic_string<charT, traits, Allocator>& str); private: basic_stringbuf<charT, traits> sb; // exposition only }; template <class charT, class traits, class Allocator> void swap(basic_stringstream<charT, traits, Allocator>& x, basic_stringstream<charT, traits, Allocator>& y); }
Шаблон класса basic_stringstream<charT, traits> поддерживает чтение и запись из объектов класса basic_string<charT, traits, Allocator>. Он использует basic_stringbuf<charT, traits, Allocator> объект для управления связанной последовательностью. Для наглядности сохраненные данные представлены здесь как
sb, stringbuf объект.
explicit basic_stringstream(
ios_base::openmode which = ios_base::out | ios_base::in);
Effects: Создает объект класса basic_stringstream<charT, traits>, инициализируя базовый класс basic_iostream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(which).
explicit basic_stringstream(
const basic_string<charT, traits, Allocator>& str,
ios_base::openmode which = ios_base::out | ios_base::in);
Effects: Создает объект класса basic_stringstream<charT, traits>, инициализируя базовый класс basic_iostream(&sb) и инициализируя sb с помощью basic_stringbuf<charT, traits, Allocator>(str, which).
basic_stringstream(basic_stringstream&& rhs);
basic_stringstream& operator=(basic_stringstream&& rhs);
void swap(basic_stringstream& rhs);
Effects: Меняет состояние *this и rhs по вызову basic_iostream<charT,traits>::swap(rhs) и sb.swap(rhs.sb).
template <class charT, class traits, class Allocator>
void swap(basic_stringstream<charT, traits, Allocator>& x,
basic_stringstream<charT, traits, Allocator>& y);
basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
basic_string<charT, traits, Allocator> str() const;
void str(const basic_string<charT, traits, Allocator>& str);