30 Input/output library [input.output]

30.8 String-based streams [string.streams]

30.8.1 Header <sstream> synopsis [sstream.syn]

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].

30.8.2 Class template basic_­stringbuf [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], 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 установлена, если выходная последовательность может быть записана.

30.8.2.1 basic_­stringbuf constructors [stringbuf.cons]

explicit basic_stringbuf( ios_base::openmode which = ios_base::in | ios_base::out);

Effects: Создает объект класса basic_­stringbuf, инициализируя базовый класс с помощью basic_­streambuf() ([streambuf.cons]) и инициализируя mode с помощью which.

Postconditions: str() == "".

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()

30.8.2.2 Assign and swap [stringbuf.assign]

basic_stringbuf& operator=(basic_stringbuf&& rhs);

Effects: После того, как присвоение хода *this приобрело наблюдаемое состояние, оно было бы, если бы оно было построено из rhs (см. [stringbuf.cons]).

Returns: *this.

void swap(basic_stringbuf& rhs);

Effects: Меняет состояние *this и rhs.

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

Effects: Как будто мимо x.swap(y).

30.8.2.3 Member functions [stringbuf.members]

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() удерживаются.

30.8.2.4 Overridden virtual functions [stringbuf.virtuals]

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).

Returns: traits​::​eof() для обозначения отказа.

Remarks: Если функция может быть успешной более чем одним из этих способов, не указано, какой путь будет выбран.

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().

Remarks: Функция может изменить количество позиций записи, доступных в результате любого вызова.

Returns: 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.

Стол 115 - seekoff позиционирование
УсловияРезультат
(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.

Таблица 116 - newoff значения
Состояние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;

Effects: Эквивалентно seekoff(off_­type(sp), ios_­base​::​beg, which).

Returns: sp для обозначения успеха или pos_­type(off_­type(-1)) неудачи.

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

Effects: определяется реализацией, за исключением того, что setbuf(0, 0) это не имеет никакого эффекта.

Returns: this.

30.8.3 Class template basic_­istringstream [istringstream]

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 объект.

30.8.3.1 basic_­istringstream constructors [istringstream.cons]

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);

Effects: Переместите конструкции из rvalue rhs. Это достигается перемещением конструирования базового класса и содержащегося в нем basic_­stringbuf. Далее basic_­istream<charT, traits>​::​set_­rdbuf(&sb) вызывается для установки содержащегося basic_­stringbuf.

30.8.3.2 Assign and swap [istringstream.assign]

basic_istringstream& operator=(basic_istringstream&& rhs);

Effects: Move назначает базу и членов *this из базы и членов-корреспондентов rhs.

Returns: *this.

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);

Effects: Как будто мимо x.swap(y).

30.8.3.3 Member functions [istringstream.members]

basic_stringbuf<charT, traits, Allocator>* rdbuf() const;

Returns: const_­cast<basic_­stringbuf<charT, traits, Allocator>*>(&sb).

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

Returns: rdbuf()->str().

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

Effects: Звонки rdbuf()->str(s).

30.8.4 Class template basic_­ostringstream [ostringstream]

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 объект.

30.8.4.1 basic_­ostringstream constructors [ostringstream.cons]

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);

Effects: Переместите конструкции из rvalue rhs. Это достигается перемещением конструирования базового класса и содержащегося в нем basic_­stringbuf. Далее basic_­ostream<charT, traits>​::​set_­rdbuf(&sb) вызывается для установки содержащегося basic_­stringbuf.

30.8.4.2 Assign and swap [ostringstream.assign]

basic_ostringstream& operator=(basic_ostringstream&& rhs);

Effects: Move назначает базу и членов *this из базы и членов-корреспондентов rhs.

Returns: *this.

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);

Effects: Как будто мимо x.swap(y).

30.8.4.3 Member functions [ostringstream.members]

basic_stringbuf<charT, traits, Allocator>* rdbuf() const;

Returns: const_­cast<basic_­stringbuf<charT, traits, Allocator>*>(&sb).

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

Returns: rdbuf()->str().

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

Effects: Звонки rdbuf()->str(s).

30.8.5 Class template basic_­stringstream [stringstream]

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 объект.

30.8.5.1 basic_­stringstream constructors [stringstream.cons]

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);

Effects: Переместите конструкции из rvalue rhs. Это достигается перемещением конструирования базового класса и содержащегося в нем basic_­stringbuf. Далее basic_­istream<charT, traits>​::​set_­rdbuf(&sb) вызывается для установки содержащегося basic_­stringbuf.

30.8.5.2 Assign and swap [stringstream.assign]

basic_stringstream& operator=(basic_stringstream&& rhs);

Effects: Move назначает базу и членов *this из базы и членов-корреспондентов rhs.

Returns: *this.

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);

Effects: Как будто мимо x.swap(y).

30.8.5.3 Member functions [stringstream.members]

basic_stringbuf<charT, traits, Allocator>* rdbuf() const;

Returns: const_­cast<basic_­stringbuf<charT, traits, Allocator>*>(&sb)

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

Returns: rdbuf()->str().

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

Effects: Звонки rdbuf()->str(str).