Простой способ создания С++ memystream из (char *, size_t) без копирования данных?

Я не мог найти ничего готового, поэтому я придумал:

class membuf : public basic_streambuf<char>
{
public:
  membuf(char* p, size_t n) {
    setg(p, p, p + n);
    setp(p, p + n);
  }
}

Использование:

char *mybuffer;
size_t length;
// ... allocate "mybuffer", put data into it, set "length"

membuf mb(mybuffer, length);
istream reader(&mb);
// use "reader"

Я знаю stringstream, но, похоже, он не может работать с двоичными данными заданной длины.

Я придумываю свое колесо здесь?

ИЗМЕНИТЬ

Он не должен копировать входные данные, просто создайте что-то, что будет перебирать данные.
Он должен быть портативным - по крайней мере, он должен работать как под gcc, так и с MSVC.

Ответ 1

Я предполагаю, что ваши входные данные являются двоичными (а не текстовыми) и что вы хотите извлечь из него куски двоичных данных. Все без копирования ваших входных данных.

Вы можете комбинировать boost::iostreams::basic_array_source и boost::iostreams::stream_buffer (от Boost.Iostreams) с помощью boost::archive::binary_iarchive (от Boost.Serialization), чтобы иметь возможность использовать удобные операции извлечения → для чтения фрагментов двоичных данных.

#include <stdint.h>
#include <iostream>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/archive/binary_iarchive.hpp>

int main()
{
    uint16_t data[] = {1234, 5678};
    char* dataPtr = (char*)&data;

    typedef boost::iostreams::basic_array_source<char> Device;
    boost::iostreams::stream_buffer<Device> buffer(dataPtr, sizeof(data));
    boost::archive::binary_iarchive archive(buffer, boost::archive::no_header);

    uint16_t word1, word2;
    archive >> word1 >> word2;
    std::cout << word1 << "," << word2 << std::endl;
    return 0;
}

С GCC 4.4.1 на AMD64 он выдает:

1234,5678

Boost.Serialization очень эффективен и знает, как сериализовать все основные типы, строки и даже контейнеры STL. Вы можете легко сделать ваши типы сериализуемыми. См. Документацию. Скрытый где-то в источниках Boost.Serialization является примером портативного двоичного архива, который знает, как выполнить правильную свопинг для вашей машинной сущности. Это может быть полезно и вам.

Если вам не нужна привязанность Boost.Serialization и с удовольствием читаем двоичные данные в стиле fread(), вы можете использовать basic_array_source более простым способом:

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

int main()
{
    uint16_t data[] = {1234, 5678};
    char* dataPtr = (char*)&data;

    typedef boost::iostreams::basic_array_source<char> Device;
    boost::iostreams::stream<Device> stream(dataPtr, sizeof(data));

    uint16_t word1, word2;
    stream.read((char*)&word1, sizeof(word1));
    stream.read((char*)&word2, sizeof(word2));
    std::cout << word1 << "," << word2 << std::endl;

    return 0;
}

Я получаю тот же результат с этой программой.

Ответ 2

Я не уверен, что вам нужно, но делает ли это то, что вам нужно?

char *mybuffer;
size_t length;
// allocate, fill, set length, as before

std::string data(mybuffer, length);
std::istringstream mb(data);
//use mb

Ответ 3

Стандартный буфер потока имеет эту функцию.
Создайте поток. Получает свой буфер, а затем перематывает его.

#include <sstream>
#include <iostream>
#include <algorithm>
#include <iterator>

int main()
{
    // Your imaginary buffer
    char    buffer[]    = "A large buffer we don't want to copy but use in a stream";

    // An ordinary stream.
    std::stringstream   str;

    // Get the streams buffer object. Reset the actual buffer being used.
    str.rdbuf()->pubsetbuf(buffer,sizeof(buffer));

    std::copy(std::istreambuf_iterator<char>(str),
              std::istreambuf_iterator<char>(),
              std::ostream_iterator<char>(std::cout)
             );
}

Ответ 4

Вопросник хотел что-то, что не копирует данные, и его решение работает нормально. Мой вклад заключается в том, чтобы немного очистить его, поэтому вы можете просто создать единый объект, который будет использоваться для ввода данных в памяти. Я тестировал это, и он работает.

class MemoryInputStream: public std::istream
    {
    public:
    MemoryInputStream(const uint8_t* aData,size_t aLength):
        std::istream(&m_buffer),
        m_buffer(aData,aLength)
        {
        rdbuf(&m_buffer); // reset the buffer after it has been properly constructed
        }

    private:
    class MemoryBuffer: public std::basic_streambuf<char>
        {
        public:
        MemoryBuffer(const uint8_t* aData,size_t aLength)
            {
            setg((char*)aData,(char*)aData,(char*)aData + aLength);
            }
        };

    MemoryBuffer m_buffer;
    };