¿Cómo leer el contenido del archivo en istringstream?

Question

Para mejorar la lectura de rendimiento de un archivo, intento leer todo el contenido de un gran archivo (varios MB) en la memoria y luego utilizar un istringstream para acceder a la información.

Mi pregunta es, ¿cuál es la mejor manera de leer esta información e "importarla" en el flujo de cadenas? Un problema con este enfoque (ver a continuación) es que al crear la secuencia de cadenas, los búferes se copian y el uso de la memoria se duplica.

#include <fstream> 
#include <sstream> 

using namespace std; 

int main() { 
    ifstream is; 
    is.open (sFilename.c_str(), ios::binary); 

    // get length of file: 
    is.seekg (0, std::ios::end); 
    long length = is.tellg(); 
    is.seekg (0, std::ios::beg); 

    // allocate memory: 
    char *buffer = new char [length]; 

    // read data as a block: 
    is.read (buffer,length); 

    // create string stream of memory contents 
    // NOTE: this ends up copying the buffer!!! 
    istringstream iss(string(buffer)); 

    // delete temporary buffer 
    delete [] buffer; 

    // close filestream 
    is.close(); 

    /* ================================== 
    * Use iss to access data 
    */ 

} 

Answer 1

std::ifstream tiene un método rdbuf(), que devuelve un puntero a una filebuf. A continuación, puede "empujar" este filebuf en su stringstream:

int main() 
{ 
    std::ifstream file("myFile"); 

    if (file) 
    { 
     std::stringstream buffer; 

     buffer << file.rdbuf(); 

     file.close(); 

     // operations on the buffer... 
    } 
} 

EDIT: Como señala Martin York en los comentarios, esto podría no ser la solución más rápida desde el stringstream 's operator<< leerá el carácter filebuf por carácter. Es posible que desee comprobar su respuesta, donde utiliza el método ifstreamread como solía hacer, y luego configurar el buffer stringstream para que apunte a la memoria previamente asignada.

Answer 2

Esto me parece una optimización prematura. Cuánto trabajo se está haciendo en el procesamiento. Asumiendo un escritorio/servidor moderno, y no un sistema integrado, copiar unos pocos MB de datos durante la inicialización es bastante barato, especialmente en comparación con leer el archivo fuera del disco en primer lugar. Me quedaría con lo que tienes, mediré el sistema cuando esté completo y decidiré si las posibles mejoras de rendimiento valdrían la pena. Por supuesto, si la memoria es escasa, se trata de un bucle interno, o de un programa al que se llama con frecuencia (como una vez por segundo), que cambia el equilibrio.

Answer 3

Otra cosa a tener en cuenta es que la E/S de archivo siempre va a ser la operación más lenta. La solución de Luc Touraille es correcta, pero hay otras opciones. Leer todo el archivo en la memoria de una vez será mucho más rápido que las lecturas por separado.

Answer 4

OK. No digo que esto sea más rápido que leer desde el archivo

Pero este es un método donde crea el búfer una vez y después de que los datos se leen en el búfer, utilícelos directamente como origen para stringstream.

N.B. Vale la pena mencionar que std :: ifstream está almacenado en el búfer. Lee datos del archivo en fragmentos (relativamente grandes). Las operaciones de flujo se realizan contra el búfer y solo regresan al archivo para otra lectura cuando se necesitan más datos. Entonces, antes de aspirar todos los datos en la memoria, verifique que se trata de un cuello de botella.

#include <fstream> 
#include <sstream> 
#include <vector> 

int main() 
{ 
    std::ifstream  file("Plop"); 
    if (file) 
    { 
     /* 
     * Get the size of the file 
     */ 
     file.seekg(0,std::ios::end); 
     std::streampos   length = file.tellg(); 
     file.seekg(0,std::ios::beg); 

     /* 
     * Use a vector as the buffer. 
     * It is exception safe and will be tidied up correctly. 
     * This constructor creates a buffer of the correct length. 
     * 
     * Then read the whole file into the buffer. 
     */ 
     std::vector<char>  buffer(length); 
     file.read(&buffer[0],length); 

     /* 
     * Create your string stream. 
     * Get the stringbuffer from the stream and set the vector as it source. 
     */ 
     std::stringstream  localStream; 
     localStream.rdbuf()->pubsetbuf(&buffer[0],length); 

     /* 
     * Note the buffer is NOT copied, if it goes out of scope 
     * the stream will be reading from released memory. 
     */ 
    } 
}