stream과 streambuf

 1template <class charT, class traits = char_traits<charT> >
 2class basic_ios : public ios_base {
 3public:
 4    typedef basic_streambuf<charT, traits> streambuf_type;
 5
 6    explicit basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
 7        : ios_base(), _M_tie(nullptr), _M_fill(_CharT(' ')), _M_state_beg(), _M_exception_mask(0),
 8          _M_streambuf_state(0), _M_streambuf(nullptr), _M_word0(0), _M_word1(0), _M_showbase(false),
 9          _M_showpoint(false), _M_uppercase(false), _M_showpos(false), _M_skipws(false), _M_science(false),
10          _M_fixed(false), _M_unitbuf(false), _M_stdio(false), _M_pword(nullptr), _M_iword(0), _M_do_lock(true)
11    {
12        // ...
13        if (__sb)
14            this->rdbuf(__sb);
15        else
16            this->rdbuf(_Traits::new_streambuf(0));
17        // ...
18    }
19
20    void init(basic_streambuf<_CharT, _Traits>* __sb) {
21        // ...
22        this->_M_tie = nullptr;
23        this->_M_fill = _CharT(' ');
24        this->_M_do_lock = true;
25        if (__sb)
26            this->rdbuf(__sb);
27        else
28            this->rdbuf(_Traits::new_streambuf(0));
29        // ...
30    }
31
32
33private:
34    // streambuf 포인터를 저장하는 멤버 변수
35    streambuf_type* _M_streambuf;
36}

 1template<typename _CharT, typename _Traits>
 2class basic_streambuf {
 3protected:
 4    // -  get == input == read
 5    // -  put == output == write
 6    char_type*        _M_in_beg;     // Start of get area. 
 7    char_type*        _M_in_cur;     // Current read area. 
 8    char_type*        _M_in_end;     // End of get area. 
 9    char_type*        _M_out_beg;    // Start of put area. 
10    char_type*        _M_out_cur;    // Current put area. 
11    char_type*        _M_out_end;    // End of put area.
12
13    void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
14        _M_in_beg = __gbeg;
15        _M_in_cur = __gnext;
16        _M_in_end = __gend;
17    }
18    void setp(char_type* __pbeg, char_type* __pend) {
19        _M_out_beg = _M_out_cur = __pbeg;
20        _M_out_end = __pend;
21    }
22
23public:
24    virtual int_type overflow(int_type /* __c */ = traits_type::eof())
25    { return traits_type::eof(); }
26
27    virtual int_type underflow()
28    { return traits_type::eof(); }
29
30    int_type sputc(char_type __c) {
31        if (__builtin_expect(this->pptr() < this->epptr(), true)) {
32            *this->pptr() = __c;
33            this->pbump(1);
34            return traits_type::to_int_type(__c);
35        }
36        return this->overflow(traits_type::to_int_type(__c));  // 버퍼가 꽉찬경우 overflow()
37    }
38
39    int_type sgetc() {
40        if (__builtin_expect(this->gptr() < this->egptr(), true)) 
41            return traits_type::to_int_type(*this->gptr());
42        return this->underflow();  // 버퍼의 데이터 읽기 끝에 도달한 경우 underflow()
43    }
44}

 1#include <sstream>
 2#include <string>
 3using namespace std;
 4
 5int main()
 6{
 7    stringstream ss;
 8    string my_string = "10 20 30";
 9    int tmp;
10    ss << my_string;
11    while (ss >> tmp) {   // 추출할 데이터가 없는경우 false
12        cout << tmp;      // 102030 출력
13    }
14    return 0;
15}

 1// my_string = "_abc_d___ef_"
 2// ret : ["", "abc", "d", "", "" , "ef", ""]
 3vector<string> weird_split(string my_string) {
 4    vector<string> answer;
 5    stringstream ss(my_string);
 6    string data;
 7    
 8    while (getline(ss, data, '_')) {
 9        answer.push_back(data);
10    }
11    return answer;
12}

 1/**** stringstream ****/
 2template<typename _CharT, typename _Traits, typename _Allocator>
 3class basic_stringstream : public basic_iostream<_CharT, _Traits>{
 4public:
 5    basic_stringstream(ios_base::openmode __mode = ios_base::out|ios_base::in)
 6        : basic_iostream<_CharT, _Traits>(&_M_stringbuf), _M_stringbuf(__mode)
 7    { }
 8
 9    explicit basic_stringstream(const basic_string<_CharT, _Traits, _Allocator>& __str,
10                                ios_base::openmode __mode = ios_base::out|ios_base::in)
11        : basic_iostream<_CharT, _Traits>(&_M_stringbuf), _M_stringbuf(__str, __mode)
12    { }
13
14private:
15    basic_stringbuf<_CharT, _Traits, _Allocator> _M_stringbuf; // 처리할 문자열 저장
16};
17
18
19/**** stringbuf ****/
20class simple_stringbuf : public std::streambuf {
21public:
22    // simple_stringbuf 생성자 예시
23    simple_stringbuf(const std::string& str, std::ios_base::openmode mode)
24        : m_str(str) {
25
26        if (mode & std::ios_base::in) {
27            setg(&m_str[0], &m_str[0], &m_str[0] + m_str.size());
28        }
29        if (mode & std::ios_base::out) {
30            setp(&m_str[0], &m_str[0] + m_str.size());
31        }
32    }
33
34private:
35    std::string m_str;   // 실제 데이터가 저장되는 버퍼
36};

 1/**** ifstream ****/
 2template<typename _CharT, typename _Traits>
 3class basic_ifstream : public basic_istream<_CharT, _Traits>
 4{
 5public:
 6    basic_ifstream() noexcept
 7        : basic_ifstream(nullptr, ios_base::in)
 8    { }
 9
10    // 파일명을 이용해 파일스트림 생성
11    explicit basic_ifstream(const char* __s,
12                            ios_base::openmode __mode = ios_base::in)
13        : basic_istream<_CharT, _Traits>(), _M_filebuf()
14    {
15        this->ios_base::init(&_M_filebuf);
16        _M_filebuf.open(__s, __mode | ios_base::in);
17    }
18
19private:
20    basic_filebuf<_CharT, _Traits> _M_filebuf;  // 입력 파일버퍼
21};
22
23
24/**** filebuf ****/
25template<typename _CharT, typename _Traits>
26class basic_filebuf : public basic_streambuf<_CharT, _Traits>
27{
28
29public:
30    explicit basic_filebuf(const char* file_name = nullptr,
31                           std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
32    : basic_streambuf<CharT, Traits>()
33    {
34        open(file_name, mode);
35    }
36
37    basic_filebuf* open(const char* __s, ios_base::openmode __mode) {
38        // _M_bufsize: 버퍼 메모리 크기를 설정하는 메소드
39        _M_bufsize = __filebuf_size;
40        // _M_buf: 실제 데이터가 저장되는 버퍼에 동적 메모리 할당
41        _M_buf = new char_type[_M_bufsize];
42        // 버퍼의 끝 포인터 설정
43        _M_buf_end = _M_buf + _M_bufsize;
44    }
45
46protected:
47    char_type* _M_buf;    // 실제 데이터가 저장되는 버퍼
48};