我如何为无符号字符向量创建某种istream

Question

如何从缓冲区unsigned char *或vector创建一个istream。

基本上我想要：

void Func(vector<unsigned char> data)
{
  someSortOfIstream x (data);

  x >> something;
}

也使用提升....

Answer 1

这可以使用Boost.IOStreams完成：

#include <iosfwd>                          // streamsize
#include <boost/iostreams/categories.hpp>  // seekable_device_tag 
#include <boost/iostreams/positioning.hpp> // stream_offset

template<typename Container>
class container_device 
{
public:
    typedef typename Container::value_type char_type;
    typedef boost::iostreams::seekable_device_tag category;

    container_device(Container& container) 
      : container_(container), pos_(0) {}

    /// Read up to n characters from the underlying data source into the 
    /// buffer s, returning the number of characters read; return -1 to 
    /// indicate EOF
    std::streamsize read(char_type* s, std::streamsize n)
    {
        std::streamsize amt = 
            static_cast<std::streamsize>(container_.size() - pos_);
        std::streamsize result = (std::min)(n, amt);
        if (result != 0) {
            std::copy(container_.begin() + pos_, 
                      container_.begin() + pos_ + result, s);
            pos_ += result;
            return result;
        } 
        else {
            return -1;  // EOF
        }
    }

    /// Write up to n characters to the underlying data sink into the 
    /// buffer s, returning the number of characters written
    std::streamsize write(const char_type* s, std::streamsize n)
    {
        std::streamsize result = 0;
        if (pos_ != container_.size()) {
            std::streamsize amt = 
                static_cast<std::streamsize>(container_.size() - pos_);
            std::streamsize result = (std::min)(n, amt);
            std::copy(s, s + result, container_.begin() + pos_);
            pos_ += result;
        }
        if (result < n) {
            container_.insert(container_.end(), s, s + n);
            pos_ = container_.size();
        }
        return n;
    }

    /// Seek to position off and return the new stream position. The 
    /// argument 'way' indicates how off is interpreted:
    ///    - std::ios_base::beg indicates an offset from the sequence 
    ///      beginning 
    ///    - std::ios_base::cur indicates an offset from the current 
    ///      character position 
    ///    - std::ios_base::end indicates an offset from the sequence end
    boost::iostreams::stream_offset seek(
        boost::iostreams::stream_offset off, std::ios_base::seekdir way)
    {
        // Determine new value of pos_
        boost::iostreams::stream_offset next;
        if (way == std::ios_base::beg) {
            next = off;
        } 
        else if (way == std::ios_base::cur) {
            next = pos_ + off;
        } 
        else if (way == std::ios_base::end) {
            next = container_.size() + off - 1;
        }

        // Check for errors
        if (next < ((boost::iostreams::stream_offset)0) 
         || next >= ((boost::iostreams::stream_offset)container_.size()))
            throw std::ios_base::failure("bad seek offset");

        pos_ = (size_type)next;
        return pos_;
    }

    Container& container() { return container_; }

private:
    typedef typename Container::size_type size_type;
    Container& container_;
    size_type pos_;
};

可以用作：

std::vector<char> data;
boost::iostreams::stream<container_device<std::vector<char> > > io(data);

和：

io << foo;
io >> bar;

Answer 2

使用Boost的非弃用解决方案：

#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/array.hpp>
using namespace boost::iostreams;

basic_array_source<char> input_source(&my_vector[0], my_vector.size());
stream<basic_array_source<char> > input_stream(input_source);

甚至更简单：

#include <boost/interprocess/streams/bufferstream.hpp>
using namespace boost::interprocess;

bufferstream input_stream(&my_vector[0], my_vector.size());

Answer 3

您还可以查看std :: stringstream。

Answer 4

我建议：

1. 使用std::string （ char的奇特向量）而不是std::vector<unsigned char> ，因为它就是它的用途。 然后，您可以在<sstream>标头中使用随时可用的std::stringstream 。

2. 您可以子类化std::vector<unsigned char> operator>>()以满足您的需要。

   要么

   （更难但理论上更好）您可以为您的案例创建子类std::iostream ，并告诉它在您使用operator>>()时该怎么做

个人我会选择1，如果你必须，请使用2a）因为坦率地说，我不知道如何将iostream子类化。