데이터를 복사하지 않고 string_view에서 문자열 스트림을 만드는 방법이 있습니까?


10

제 생각에는 아주 간단한 질문입니다. 특별히을 사용하고 싶지만 std::get_time일종의 스트림을 사용해야합니다. 에 데이터를 전달 string_view하고 날짜를 구문 분석하기 위해 복사하지 않도록하고 싶습니다.


1
C ++ 23에 와서 지금 볼 수 있습니다. std::basic_string_view_stream;-) 복사를 피할 수 있는지 확실하지 않습니다. 하워드가 트릭을 알게 될 것입니다.
NathanOliver

2
더 이상 사용되지 std::strstream않는 것이 그렇게 할 수 있습니다.
Igor Tandetnik

우리 가이 프로젝트에 있기 때문에이 C ++ 14 태그를 잘못 태그했습니다. 실제로 우리가 사용하는 것을 잊었습니다 boost::string_view. 그러나이 질문은 여전히 ​​유효합니다.
Bartek Banachewicz

답변:


5

Boost.Iostreams 라이브러리를 사용하면 쉽게 할 수 있습니다.

#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>

#include <iostream>
#include <string>

int main() {
    std::string_view buf{"hello\n"};
    boost::iostreams::stream<boost::iostreams::basic_array_source<char>> stream(buf.begin(), buf.size());

    std::string s;
    stream >> s;
    std::cout << s << '\n';
}

당신은에 그렇게 할 수 있어야 std::stringstream하고 std::basic_stringbuf<CharT,Traits,Allocator>::setbuf있지만, C ++ 표준의 요구 사항을 망친 :

[의 효과 setbuf] 구현 정의되고 일부 구현 지우기 동안 일부 구현 예는, 아무것도하지 않고 std::string현재 버퍼로서 사용되는 부재 및 크기의 사용자 제공 문자 배열을 사용하기 n그의 첫번째 소자에 의해 지시되어, s상기 버퍼로서 및 입출력 문자 순서


1

Boost.IOstream이없는 대체 솔루션 (사용할 수없는 경우). std :: basic_streambuf 및 std :: basic_istream 확장을 기반으로합니다.

#include <cstring>
#include <iostream>
#include <istream>
#include <string_view>

template<typename __char_type, class __traits_type >
class view_streambuf final: public std::basic_streambuf<__char_type, __traits_type > {
private:
    typedef std::basic_streambuf<__char_type, __traits_type > super_type;
    typedef view_streambuf<__char_type, __traits_type> self_type;
public:

    /**
    *  These are standard types.  They permit a standardized way of
    *  referring to names of (or names dependent on) the template
    *  parameters, which are specific to the implementation.
    */
    typedef typename super_type::char_type char_type;
    typedef typename super_type::traits_type traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::pos_type pos_type;
    typedef typename traits_type::off_type off_type;

    typedef typename std::basic_string_view<char_type, traits_type> source_view;

    view_streambuf(const source_view& src) noexcept:
      super_type(),
      src_( src )
    {
        char_type *buff = const_cast<char_type*>( src_.data() );
        this->setg( buff , buff, buff + src_.length() );
    }

    virtual std::streamsize xsgetn(char_type* __s, std::streamsize __n) override
    {
        if(0 == __n)
            return 0;
        if( (this->gptr() + __n) >= this->egptr() ) {
            __n =  this->egptr() - this->gptr();
            if(0 == __n && !traits_type::not_eof( this->underflow() ) )
                return -1;
        }
        std::memmove( static_cast<void*>(__s), this->gptr(), __n);
        this->gbump( static_cast<int>(__n) );
        return __n;
    }

    virtual int_type pbackfail(int_type __c) override
    {
        char_type *pos = this->gptr() - 1;
        *pos = traits_type::to_char_type( __c );
        this->pbump(-1);
        return 1;
    }

    virtual int_type underflow() override
    {
        return traits_type::eof();
    }

    virtual std::streamsize showmanyc() override
    {
        return static_cast<std::streamsize>( this->egptr() - this->gptr() );
    }

    virtual ~view_streambuf() override
    {}
private:
    const source_view& src_;
};

template<typename _char_type>
class view_istream final:public std::basic_istream<_char_type, std::char_traits<_char_type> > {
    view_istream(const view_istream&) = delete;
    view_istream& operator=(const view_istream&) = delete;
private:
    typedef std::basic_istream<_char_type, std::char_traits<_char_type> > super_type;
    typedef view_streambuf<_char_type, std::char_traits<_char_type> > streambuf_type;
public:
    typedef _char_type  char_type;
    typedef typename super_type::int_type int_type;
    typedef typename super_type::pos_type pos_type;
    typedef typename super_type::off_type off_type;
    typedef typename super_type::traits_type traits_type;
    typedef typename streambuf_type::source_view source_view;

    view_istream(const source_view& src):
        super_type( nullptr ),
        sb_(nullptr)
    {
        sb_ = new streambuf_type(src);
        this->init( sb_ );
    }


    view_istream(view_istream&& other) noexcept:
        super_type( std::forward<view_istream>(other) ),
        sb_( std::move( other.sb_ ) )
    {}

    view_istream& operator=(view_istream&& rhs) noexcept
    {
        view_istream( std::forward<view_istream>(rhs) ).swap( *this );
        return *this;
    }

    virtual ~view_istream() override {
        delete sb_;
    }

private:
    streambuf_type *sb_;
};


int main(int argc, const char** argv)
{
    std::string_view v("ABDCD\n 123\n FAG\n 456789");

    view_istream<char> in( v );

    std::string s;
    in >> s;
    std::cout << s << std::endl;

    int i;
    in >> i;
    std::cout << i << std::endl;

    in >> s;
    std::cout << s << std::endl;

    in >> i;
    std::cout << i << std::endl;

    return 0;
}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.