# 标准库头文件 <strstream>

< cpp‎ | header

此头文件是输入/输出库的一部分。

### 类
strstreambuf (C++98 中弃用) | 实现原生字符数组设备 (类)
istrstream (C++98 中弃用) | 实现字符数组输入操作 (类)
ostrstream (C++98 中弃用) | 实现字符数组输出操作 (类)
strstream (C++98 中弃用) | 实现字符数组输入/输出操作 (类)

### 概要

    namespace std {
      class strstreambuf;
      class istrstream;
      class ostrstream;
      class strstream;
    }

#### 类 std::strstreambuf

    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 = /*位掩码类型*/;      // 仅用于阐释
        static const strstate allocated;    // 仅用于阐释
        static const strstate constant;     // 仅用于阐释
        static const strstate dynamic;      // 仅用于阐释
        static const strstate frozen;       // 仅用于阐释
        strstate strmode;                   // 仅用于阐释
        streamsize alsize;                  // 仅用于阐释
        void* (*palloc)(size_t);            // 仅用于阐释
        void (*pfree)(void*);               // 仅用于阐释
      };
    }

#### 类 std::istrstream

    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;            // 仅用于阐释
      };
    }

#### 类 std::ostrstream

    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;            // 仅用于阐释
      };
    }

#### 类 std::strstream

    namespace std {
      class strstream
        : public basic_iostream<char> {
      public:
        // 类型
        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;

        // 构造函数/析构函数
        strstream();
        strstream(char* s, int n,
                  ios_base::openmode mode = ios_base::in | ios_base::out);
        virtual ~strstream();

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

      private:
        strstreambuf sb;            // 仅用于阐释
      };
    }