C++ equivalente de Java ByteBuffer?

Question

Estoy buscando un C ++ "equivalente" de Java ByteBuffer.

Probablemente me esté perdiendo lo obvio o simplemente necesito un ejemplo de uso aislado para aclarar. He mirado a través de la familia de iostream y parece que puede proporcionar una base. Específicamente, quiero poder:

• construir un búfer a partir de una matriz / punto de bytes y obtener primitivos del búfer, por ejemplo, getByte, getInt
• cree un búfer usando primitivas, por ejemplo, putByte, putInt y luego obtenga el byte array / pointer.

Answer 1

Escribí esto hace un tiempo para hacer exactamente lo que estás pidiendo. Dale un tiro:

https://code.google.com/p/bytebuffer-cpp/

Answer 2

Gracias por todos los comentarios, ha conducido a esta solución bastante simple:

class ByteBuffer : std::stringbuf
{
public:
template
size_t get( T &out)
{
union coercion { T value; char data[ sizeof ( T ) ]; };
coercion c;
size_t s= xsgetn( c.data, sizeof(T));
out= c.value;
return s;
}
template
size_t put( T &in)
{
union coercion { T value; char data[ sizeof ( T ) ]; };
coercion c;
c.value= in;
return xsputn( c.data, sizeof(T));
}
size_t get( uint8_t *out, size_t count)
{
return xsgetn((char *)out, count);
}
size_t put( uint8_t *out, size_t count)
{
return xsputn((char *)out, count);
}
};

Para usar por ejemplo:

void ByteBufferTest( void)
{
ByteBuffer bb;
float f= 4;
uint8_t u8= 1;
uint16_t u16= 2;
uint32_t u32= 4;
uint64_t u64= 8;
bb.put(f);
bb.put(u8);
bb.put(u16);
bb.put(u32);
bb.put(u64);
uint8_t array[19];
bb.get( array, 19);
// or
bb.get(f);
bb.get(u8);
bb.get(u16);
bb.get(u32);
bb.get(u64);
}

Answer 3

Tienes stringbuf , filebuf o podrías usar vector<char> .

Este es un ejemplo simple usando stringbuf :

std::stringbuf buf;
char data[] = {0, 1, 2, 3, 4, 5};
char tempbuf[sizeof data];
buf.sputn(data, sizeof data); // put data
buf.sgetn(tempbuf, sizeof data); // get data

Gracias a @Pete Kirkham por la idea de funciones genéricas.

#include <sstream>
template <class Type>
std::stringbuf& put(std::stringbuf& buf, const Type& var)
{
buf.sputn(reinterpret_cast<const char*>(&var), sizeof var);
return buf;
}
template <class Type>
std::stringbuf& get(std::stringbuf& buf, Type& var)
{
buf.sgetn(reinterpret_cast<char*>(&var), sizeof(var));
return buf;
}
int main()
{
std::stringbuf mybuf;
char byte = 0;
int var;
put(mybuf, byte++);
put(mybuf, byte++);
put(mybuf, byte++);
put(mybuf, byte++);
get(mybuf, var);
}

Answer 4

para std :: vector más eficiente es el método

push_back(T) 

Puedes encontrar más aquí:

http://www.cppreference.com/wiki/stl/vector/start

y en general sobre cpp stl libs

http://www.cppreference.com/wiki/stl/start

Hay muchos contenedores, depende para que lo necesitas,

• agregación de velocidad (capacidades de escritura rápida) o
• lectura rápida

Echa un vistazo a std :: list, std :: vector.

Answer 5

stringstream proporciona stringstream básicas de stringstream y write sin formato para escribir bloques de caracteres. Para especializarse en T ya sea subclase o envolverla, o proporcionar funciones de plantilla independientes para usar la memoria de tamaño adecuado para obtener / escribir.

template <typename T>
std::stringstream& put ( std::stringstream& str, const T& value )
{
union coercion { T value; char data[ sizeof ( T ) ]; };
coercion c;
c.value = value;
str.write ( c.data, sizeof ( T ) );
return str;
}
template <typename T>
std::stringstream& get ( std::stringstream& str, T& value )
{
union coercion { T value; char data[ sizeof ( T ) ]; };
coercion c;
c.value = value;
str.read ( c.data, sizeof ( T ) );
value = c.value;
return str;
}

Podría escribir dichas plantillas para cualquier otra secuencia o vector que desee; en el caso del vector, tendría que usar insertar en lugar de escribir.

Answer 6

std::vector<char> bytes;
bytes.push_back( some_val ); // put
char x = bytes[N]; // get
const char* ptr = &bytes[0]; // pointer to array