Lectura directamente de std :: istream en std :: string

Question

¿Hay alguna forma de leer un número conocido de bytes, directamente en std :: string, sin crear un búfer temporal para hacerlo?

por ejemplo, actualmente puedo hacerlo por

boost::uint16_t len; 
is.read((char*)&len, 2); 
char *tmpStr = new char[len]; 
is.read(tmpStr, len); 
std::string str(tmpStr, len); 
delete[] tmpStr; 

Answer 1

std::string tiene una función resize podría utilizar, o un constructor que va a hacer lo mismo:

boost::uint16_t len; 
is.read((char*)&len, 2); 

std::string str(len, '\0'); 
is.read(&str[0], len); 

Esto no se ha probado, y yo no sé si las cadenas tienen el mandato de tener un almacenamiento contiguo.

Answer 2

¿Está optimizando la longitud del código o tratando de ahorrar una copia aquí? ¿Qué pasa con el buffer temporal?

Argumentaría que en realidad estás eludiendo las protecciones de la cuerda que intenta escribir directamente, hazlo así. Si le preocupa el rendimiento de la copia en std :: string porque ha identificado que de alguna manera está afectando el rendimiento de su aplicación, trabajaría directamente con el char *.

EDIT:. Hacer más mirando ... initializing std::string from char* without copy

En la segunda respuesta, se declaró muy rotundamente que no se puede lograr lo que busca lograr (es decir, llenar un std :: string sin una iteración sobre el char * para copiar)

Eche un vistazo a su rutina de carga (¿lo puede publicar aquí quizás?) y minimice las asignaciones: nuevo y elimine ciertamente no son gratis así que al menos puede ahorrar algo de tiempo no tiene que volver a crear el búfer constantemente. Siempre me resulta útil borrarlo insertando el búfer en 0 o cancelando el primer índice de la matriz en cada iteración, pero puede eliminarlo rápidamente en interés del rendimiento una vez que tenga confianza en su algoritmo.

Answer 3

Se podría utilizar algo como getline:

#include <iostream> 
#include <string> 
using namespace std; 

int main() { 
    string str; 
    getline (cin,str,' '); 
} 

Answer 4

me gustaría utilizar un vector como el tampón.

boost::uint16_t len; 
is.read((char*)&len, 2); // Note if this file was saved from a different architecture 
         // then endianness of these two bytes may be reversed. 

std::vector buffer(len); // uninitialized. 
is.read(&buffer[0], len); 

std::string str(buffer.begin(),buffer.end()); 

Aunque probablemente se saldrá con la suya utilizando una cadena como el búfer (según lo descrito por GMan). No está garantizado por el estándar que los miembros de cadenas se encuentren en ubicaciones consecutivas (por lo tanto, verifique su implementación actual y haga un comentario importante que necesite verificar al transferir a otro compilador/plataforma).

Answer 5

se puede utilizar una combinación de copy_n y un insert_iterator

void test_1816319() 
{ 
    static char const* fname = "test_1816319.bin"; 
    std::ofstream ofs(fname, std::ios::binary); 
    ofs.write("\x2\x0", 2); 
    ofs.write("ab", 2); 
    ofs.close(); 

    std::ifstream ifs(fname, std::ios::binary); 
    std::string s; 
    size_t n = 0; 
    ifs.read((char*)&n, 2); 
    std::istream_iterator<char> isi(ifs), isiend; 
    std::copy_n(isi, n, std::insert_iterator<std::string>(s, s.begin())); 
    ifs.close(); 
    _unlink(fname); 

    std::cout << s << std::endl; 
} 

ninguna copia, sin trucos, sin posibilidad de desbordamiento, hay un comportamiento indefinido.

Answer 6

Una manera fácil sería:

std::istream& data 
const size_t dataSize(static_cast<size_t>(data.rdbuf()->in_avail())); 
std::string content; 
content.reserve(dataSize); 
data.read(&content[0], dataSize);