Namespaces
Variants

Standard library header <sstream>

From cppreference.net
C++
Standard library headers

이 헤더는 Input/Output 라이브러리의 일부입니다.

목차

클래스

원시 문자열 장치를 구현함
(클래스 템플릿)
고수준 문자열 스트림 입력 연산을 구현함
(클래스 템플릿)
고수준 문자열 스트림 출력 연산을 구현함
(클래스 템플릿)
고수준 문자열 스트림 입출력 연산을 구현함
(클래스 템플릿)
stringbuf std:: basic_stringbuf < char >
(typedef)
wstringbuf std:: basic_stringbuf < wchar_t >
(typedef)
istringstream std:: basic_istringstream < char >
(typedef)
wistringstream std:: basic_istringstream < wchar_t >
(typedef)
ostringstream std:: basic_ostringstream < char >
(typedef)
wostringstream std:: basic_ostringstream < wchar_t >
(typedef)
stringstream std:: basic_stringstream < char >
(typedef)
wstringstream std:: basic_stringstream < wchar_t >
(typedef)

함수

(C++11)
std::swap 알고리즘을 특수화합니다
(함수 템플릿)
(C++11)
std::swap 알고리즘을 특수화함
(함수 템플릿)
(C++11)
std::swap 알고리즘을 특수화함
(함수 템플릿)
(C++11)
std::swap 알고리즘을 특수화함
(함수 템플릿)

시놉시스 

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>;
}
**참고:** 제공된 텍스트는 C++ 코드 조각으로, 번역이 필요한 일반 텍스트가 포함되어 있지 않습니다. 모든 내용이 HTML 태그, 코드 태그( , 
), 그리고 C++ 특정 용어로 구성되어 있어 번역 대상이 없습니다. 원본 형식과 내용이 그대로 유지되었습니다.

클래스 템플릿 std::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;
    // 생성자
    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);
    basic_stringbuf(const basic_stringbuf&) = delete;
    basic_stringbuf(basic_stringbuf&& rhs);
    basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
    // 할당 및 교환
    basic_stringbuf& operator=(const basic_stringbuf&) = delete;
    basic_stringbuf& operator=(basic_stringbuf&& rhs);
    void swap(basic_stringbuf& rhs) noexcept(see below);
    // 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);
  protected:
    // 재정의된 가상 함수
    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;                        // 설명 전용
    basic_string<CharT, Traits, Allocator> buf;     // 설명 전용
    void init_buf_ptrs();                           // 설명 전용
  };
  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)));
}

클래스 템플릿 std::basic_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;
    // 생성자
    basic_istringstream() : basic_istringstream(ios_base::in) {}
    explicit basic_istringstream(ios_base::openmode which);
    explicit basic_istringstream(
      const basic_string<CharT, Traits, Allocator>& s,
      ios_base::openmode which = ios_base::in);
    basic_istringstream(ios_base::openmode which, const Allocator& a);
    explicit basic_istringstream(
      basic_string<CharT, Traits, Allocator>&& s,
      ios_base::openmode which = ios_base::in);
    template<class SAlloc>
      basic_istringstream(
        const basic_string<CharT, Traits, SAlloc>& s, const Allocator& a)
        : basic_istringstream(s, ios_base::in, a) {}
    template<class SAlloc>
      basic_istringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which, const Allocator& a);
    template<class SAlloc>
      explicit basic_istringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which = ios_base::in);
    basic_istringstream(const basic_istringstream&) = delete;
    basic_istringstream(basic_istringstream&& rhs);
    // 할당 및 교환
    basic_istringstream& operator=(const basic_istringstream&) = delete;
    basic_istringstream& operator=(basic_istringstream&& rhs);
    void swap(basic_istringstream& rhs);
    // 멤버 함수
    basic_stringbuf<CharT, Traits, Allocator>* rdbuf() const;
    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);
  private:
    basic_stringbuf<CharT, Traits, Allocator> sb;   // 설명 전용
  };
  template<class CharT, class Traits, class Allocator>
    void swap(basic_istringstream<CharT, Traits, Allocator>& x,
              basic_istringstream<CharT, Traits, Allocator>& y);
}

클래스 템플릿 std::basic_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;
    // 생성자
    basic_ostringstream() : basic_ostringstream(ios_base::out) {}
    explicit basic_ostringstream(ios_base::openmode which);
    explicit basic_ostringstream(
      const basic_string<CharT, Traits, Allocator>& s,
      ios_base::openmode which = ios_base::out);
    basic_ostringstream(ios_base::openmode which, const Allocator& a);
    explicit basic_ostringstream(
      basic_string<CharT, Traits, Allocator>&& s,
      ios_base::openmode which = ios_base::out);
    template<class SAlloc>
      basic_ostringstream(
        const basic_string<CharT, Traits, SAlloc>& s, const Allocator& a)
        : basic_ostringstream(s, ios_base::out, a) {}
    template<class SAlloc>
      basic_ostringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which, const Allocator& a);
    template<class SAlloc>
      explicit basic_ostringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which = ios_base::out);
    basic_ostringstream(const basic_ostringstream&) = delete;
    basic_ostringstream(basic_ostringstream&& rhs);
    // 할당 및 교환
    basic_ostringstream& operator=(const basic_ostringstream&) = delete;
    basic_ostringstream& operator=(basic_ostringstream&& rhs);
    void swap(basic_ostringstream& rhs);
    // 멤버 함수
    basic_stringbuf<CharT, Traits, Allocator>* rdbuf() const;
    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);
   private:
    basic_stringbuf<CharT, Traits, Allocator> sb;   // 설명 전용
  };
  template<class CharT, class Traits, class Allocator>
    void swap(basic_ostringstream<CharT, Traits, Allocator>& x,
              basic_ostringstream<CharT, Traits, Allocator>& y);
}

클래스 템플릿 std::basic_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;
    // 생성자
    basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
    explicit basic_stringstream(ios_base::openmode which);
    explicit basic_stringstream(
      const basic_string<CharT, Traits, Allocator>& s,
      ios_base::openmode which = ios_base::out | ios_base::in);
    basic_stringstream(ios_base::openmode which, const Allocator& a);
    explicit basic_stringstream(
      basic_string<CharT, Traits, Allocator>&& s,
      ios_base::openmode which = ios_base::out | ios_base::in);
    template<class SAlloc>
      basic_stringstream(
        const basic_string<CharT, Traits, SAlloc>& s, const Allocator& a)
        : basic_stringstream(s, ios_base::out | ios_base::in, a) {}
    template<class SAlloc>
      basic_stringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which, const Allocator& a);
    template<class SAlloc>
      explicit basic_stringstream(
        const basic_string<CharT, Traits, SAlloc>& s,
        ios_base::openmode which = ios_base::out | ios_base::in);
    basic_stringstream(const basic_stringstream&) = delete;
    basic_stringstream(basic_stringstream&& rhs);
    // 할당 및 교환
    basic_stringstream& operator=(const basic_stringstream&) = delete;
    basic_stringstream& operator=(basic_stringstream&& rhs);
    void swap(basic_stringstream& rhs);
    // 멤버 함수
    basic_stringbuf<CharT, Traits, Allocator>* rdbuf() const;
    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);
  private:
    basic_stringbuf<CharT, Traits> sb;  // 설명 전용
  };
  template<class CharT, class Traits, class Allocator>
    void swap(basic_stringstream<CharT, Traits, Allocator>& x,
              basic_stringstream<CharT, Traits, Allocator>& y);
}

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
LWG 170 C++98 traits_type 정의가 다음의 개요에서 누락됨
std::basic_ostringstream 및 std::basic_stringstream 		추가됨
LWG 251 C++98 allocator_type 정의가 다음의 개요에서 누락됨
std::basic_stringbuf , std::basic_istringstream
std::basic_ostringstream 및 std::basic_stringstream 		추가됨