Obtener un istream de un char*

Una solución no obsoleta usando Boost:

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

basic_array_source<char> input_source(my_ptr_to_char, byte_count);
stream<basic_array_source<char> > input_stream(input_source);

O aún más simple:

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

bufferstream input_stream(my_ptr_to_char, byte_count);

Necesitaba una solución que soportara tellg y seekg y no requería boost.

char_array_buffer from A beginner's guide to writing a custom stream buffer (std::streambuf) dio un punto de partida got.

Byte_array_buffer.h:

#include <cstdio>
#include <string>
#include <list>
#include <fstream>
#include <iostream>

//
// http://www.mr-edd.co.uk/blog/beginners_guide_streambuf
//

class byte_array_buffer : public std::streambuf
{
public:
    byte_array_buffer(const uint8_t *begin, const size_t size);

private:
    int_type underflow();
    int_type uflow();
    int_type pbackfail(int_type ch);
    std::streamsize showmanyc();
    std::streampos seekoff ( std::streamoff off, std::ios_base::seekdir way,
                            std::ios_base::openmode which = std::ios_base::in | std::ios_base::out );
    std::streampos seekpos ( std::streampos sp,
                            std::ios_base::openmode which = std::ios_base::in | std::ios_base::out);

    // copy ctor and assignment not implemented;
    // copying not allowed
    byte_array_buffer(const byte_array_buffer &);
    byte_array_buffer &operator= (const byte_array_buffer &);

private:
    const uint8_t * const begin_;
    const uint8_t * const end_;
    const uint8_t * current_;
};

Byte_array_buffer.cpp:

#include "byte_array_buffer.h"

#include <cassert>


byte_array_buffer::byte_array_buffer(const uint8_t *begin, const size_t size) :
begin_(begin),
end_(begin + size),
current_(begin_)
{
    assert(std::less_equal<const uint8_t *>()(begin_, end_));
}

byte_array_buffer::int_type byte_array_buffer::underflow()
{
    if (current_ == end_)
        return traits_type::eof();

    return traits_type::to_int_type(*current_);
}

byte_array_buffer::int_type byte_array_buffer::uflow()
{
    if (current_ == end_)
        return traits_type::eof();

    return traits_type::to_int_type(*current_++);
}

byte_array_buffer::int_type byte_array_buffer::pbackfail(int_type ch)
{
    if (current_ == begin_ || (ch != traits_type::eof() && ch != current_[-1]))
        return traits_type::eof();

    return traits_type::to_int_type(*--current_);
}

std::streamsize byte_array_buffer::showmanyc()
{
    assert(std::less_equal<const uint8_t *>()(current_, end_));
    return end_ - current_;
}


std::streampos byte_array_buffer::seekoff ( std::streamoff off, std::ios_base::seekdir way,
                                           std::ios_base::openmode which )
{
    if (way == std::ios_base::beg)
    {
        current_ = begin_ + off;
    }
    else if (way == std::ios_base::cur)
    {
        current_ += off;
    }
    else if (way == std::ios_base::end)
    {
        current_ = end_;
    }

    if (current_ < begin_ || current_ > end_)
        return -1;


    return current_ - begin_;
}

std::streampos byte_array_buffer::seekpos ( std::streampos sp,
                                           std::ios_base::openmode which )
{
    current_ = begin_ + sp;

    if (current_ < begin_ || current_ > end_)
        return -1;

    return current_ - begin_;
}

La única manera (simple) portátil incluye hacer la copia:

std::istringstream ss(std::string(buf,len));

De hecho, es probable que copie los datos dos veces, una para crear el string y otra para crear el istringstream. (Tal vez C++11 puede evitar una de las copias a través de un constructor de movimiento; no estoy seguro.)

Sin embargo, si tiene suerte, su implementación de C++ le permitirá hacer esto:

std::istringstream ss;
ss.rdbuf()->pubsetbuf(buf,len);

Bajo GNU C++ (y, creo, algunas otras implementaciones), esto creará el stringstream sin copiar los datos. Pero esto es un comportamiento "definido por la implementación" de acuerdo con la especificación. (Véase también esta pregunta.)

Al incluir el parámetro len, se asegura de que ambos no tendrán ningún problema con los caracteres null.

La única forma portable de hacer lo que quieres es implementar tu propia subclase de stringbuf y usarla para inicializar el stringstream. No para los débiles de corazón.

¿Has probado std:: istream? http://stdcxx.apache.org/doc/stdlibref/istrstream.html

Técnicamente, creo que está en desuso, pero sigue siendo parte del estándar.

Prueba el Impulso.Iostreams array source y sink classes.

Http://www.boost.org/doc/libs/1_47_0/libs/iostreams/doc/index.html