View source for cpp/header/strstream

{{cpp/header/title|strstream|notes={{mark life|deprecated=c++98|removed=c++26}}}}
{{cpp/header/navbar}}

This header is part of the [[cpp/io|Input/Output]] library.

{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc|cpp/io/dsc strstreambuf}}
{{dsc inc|cpp/io/dsc istrstream}}
{{dsc inc|cpp/io/dsc ostrstream}}
{{dsc inc|cpp/io/dsc strstream}}
{{dsc end}}

===Notes===
{{header|strstream}} is deprecated in C++98 and removed in C++26 (see {{stddoc|P2867R1}}).

The reason for removal is that C++20 and C++23 provide superior replacement facilities, such as the ability to move strings efficiently out of {{lc|std::basic_stringstream|std::stringstream}}s (since C++20, see {{stddoc|P0408R7}}), and the {{header|spanstream}} library (since C++23, see {{stddoc|P0448R4}}).

===Synopsis===
{{source|
namespace std {
  class strstreambuf;
  class istrstream;
  class ostrstream;
  class strstream;
}
}}

====Class {{lc|std::strstreambuf}}====
{{source|1=
namespace std {
  class strstreambuf : public basic_streambuf<char> {
  public:
    strstreambuf() : strstreambuf(0) {}
    explicit strstreambuf(streamsize alsize_arg);
    strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
    strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);
    strstreambuf(const char* gnext_arg, streamsize n);

    strstreambuf(signed char* gnext_arg, streamsize n,
                 signed char* pbeg_arg = nullptr);
    strstreambuf(const signed char* gnext_arg, streamsize n);
    strstreambuf(unsigned char* gnext_arg, streamsize n,
                 unsigned char* pbeg_arg = nullptr);
    strstreambuf(const unsigned char* gnext_arg, streamsize n);

    virtual ~strstreambuf();

    void  freeze(bool freezefl = true);
    char* str();
    int   pcount();

  protected:
    int_type overflow (int_type c = EOF) override;
    int_type pbackfail(int_type c = EOF) override;
    int_type underflow() 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;
    streambuf* setbuf(char* s, streamsize n) override;

  private:
    using strstate = /*bitmask type*/;  // exposition only
    static const strstate allocated;    // exposition only
    static const strstate constant;     // exposition only
    static const strstate dynamic;      // exposition only
    static const strstate frozen;       // exposition only
    strstate strmode;                   // exposition only
    streamsize alsize;                  // exposition only
    void* (*palloc)(size_t);            // exposition only
    void (*pfree)(void*);               // exposition only
  };
}
}}

====Class {{lc|std::istrstream}}====
{{source|1=
namespace std {
  class istrstream : public basic_istream<char> {
  public:
    explicit istrstream(const char* s);
    explicit istrstream(char* s);
    istrstream(const char* s, streamsize n);
    istrstream(char* s, streamsize n);
    virtual ~istrstream();

    strstreambuf* rdbuf() const;
    char* str();
  private:
    strstreambuf sb;            // exposition only
  };
}
}}

====Class {{lc|std::ostrstream}}====
{{source|1=
namespace std {
  class ostrstream : public basic_ostream<char> {
  public:
    ostrstream();
    ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
    virtual ~ostrstream();

    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    char* str();
    int pcount() const;
  private:
    strstreambuf sb;            // exposition only
  };
}
}}

====Class {{lc|std::strstream}}====
{{source|1=
namespace std {
  class strstream
    : public basic_iostream<char> {
  public:
    // types
    using char_type = char;
    using int_type  = char_traits<char>::int_type;
    using pos_type  = char_traits<char>::pos_type;
    using off_type  = char_traits<char>::off_type;

    // constructors/destructor
    strstream();
    strstream(char* s, int n,
              ios_base::openmode mode = ios_base::in {{!}} ios_base::out);
    virtual ~strstream();

    // members
    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    int pcount() const;
    char* str();

  private:
    strstreambuf sb;            // exposition only
  };
}
}}

{{langlinks|es|ja|zh}}