Lea todo el archivo ASCII en C++ std :: string

Question

Necesito leer un archivo completo en la memoria y colocarlo en C++ std::string.

Si tuviera que leerlo en un char[], la respuesta sería muy simple:

std::ifstream t; 
int length; 
t.open("file.txt");  // open input file 
t.seekg(0, std::ios::end); // go to the end 
length = t.tellg();   // report location (this is the length) 
t.seekg(0, std::ios::beg); // go back to the beginning 
buffer = new char[length]; // allocate memory for a buffer of appropriate dimension 
t.read(buffer, length);  // read the whole file into the buffer 
t.close();     // close file handle 

// ... Do stuff with buffer here ... 

Ahora, yo quiero hacer exactamente lo mismo, pero usando un std::string en lugar de un char[]. Quiero evitar bucles, es decir, que no quiero:

std::ifstream t; 
t.open("file.txt"); 
std::string buffer; 
std::string line; 
while(t){ 
std::getline(t, line); 
// ... Append line to buffer and go on 
} 
t.close() 

¿Alguna idea?

Answer 1

Actualización: Resulta que este método, aunque sigue bien las expresiones idiomáticas STL, ¡es sorprendentemente ineficiente! No hagas esto con archivos grandes. (Ver: http://insanecoding.blogspot.com/2011/11/how-to-read-in-file-in-c.html)

Usted puede hacer un iterador streambuf fuera del archivo e inicializar la cadena con él:

#include <string> 
#include <fstream> 
#include <streambuf> 

std::ifstream t("file.txt"); 
std::string str((std::istreambuf_iterator<char>(t)), 
       std::istreambuf_iterator<char>()); 

No está seguro de dónde obtiene la sintaxis de t.open("file.txt", "r"). Por lo que sé, ese no es un método que tiene std::ifstream. Parece que lo has confundido con C fopen.

Editar: También tenga en cuenta el paréntesis adicional alrededor del primer argumento para el constructor de cadenas. Estos son esenciales. Evitan el problema conocido como "most vexing parse", que en este caso no le dará un error de compilación como suele hacerlo, pero le dará resultados interesantes (leer: incorrecto).

Siguiendo punto de KeithB en los comentarios, he aquí una manera de hacerlo que asigna toda la memoria por adelantado (en lugar de depender de reasignación automática de la clase string):

#include <string> 
#include <fstream> 
#include <streambuf> 

std::ifstream t("file.txt"); 
std::string str; 

t.seekg(0, std::ios::end); 
str.reserve(t.tellg()); 
t.seekg(0, std::ios::beg); 

str.assign((std::istreambuf_iterator<char>(t)), 
      std::istreambuf_iterator<char>()); 

Answer 2

no creo que pueda Haga esto sin un bucle explícito o implícito, sin leer en una matriz char (o algún otro contenedor) primero y diez construyendo la cadena. Si no necesita las otras capacidades de una cadena, podría hacerlo con vector<char> de la misma manera que está utilizando actualmente un char *.

Answer 3

Hay un par de posibilidades. Uno me gusta usar un stringstream como un intermediario:

std::ifstream t("file.txt"); 
std::stringstream buffer; 
buffer << t.rdbuf(); 

Ahora el contenido de "archivo.txt" están disponibles en una cadena como buffer.str().

Otra posibilidad (aunque sin duda no me gusta así) es mucho más como el original:

std::ifstream t("file.txt"); 
t.seekg(0, std::ios::end); 
size_t size = t.tellg(); 
std::string buffer(size, ' '); 
t.seekg(0); 
t.read(&buffer[0], size); 

Oficialmente, esto no es necesario trabajar bajo el estándar de C++ 98 o 03 (no se requiere cadena para almacenar datos de forma contigua), pero de hecho funciona con todas las implementaciones conocidas, y C++ 11 y posterior requieren almacenamiento contiguo, por lo que está garantizado para trabajar con ellos.

En cuanto a por qué no me gusta este último también: primero, porque es más largo y más difícil de leer.En segundo lugar, porque requiere que inicialices el contenido de la cadena con datos que no te interesan, inmediatamente escribe esos datos (sí, el tiempo para inicializar suele ser trivial en comparación con la lectura, por lo que probablemente no importe) , pero para mí todavía se siente un poco mal). Tercero, en un archivo de texto, la posición X en el archivo no necesariamente significa que habrá leído X caracteres para llegar a ese punto; no es necesario tener en cuenta cosas como las traducciones de final de línea. En los sistemas reales que hacen tales traducciones (por ejemplo, Windows), el formulario traducido es más corto que el contenido del archivo (es decir, "\ r \ n" en el archivo se convierte en "\ n" en la cadena traducida) así que todo lo que ha hecho está reservado un poco de espacio extra que nunca usas. Una vez más, realmente no causa un problema importante, pero se siente un poco mal de todos modos.

Answer 4

que podía hacerlo de esta manera:

void readfile(const std::string &filepath,std::string &buffer){ 
    std::ifstream fin(filepath.c_str()); 
    getline(fin, buffer, char(-1)); 
    fin.close(); 
} 

Si esto es algo que debe ser mal visto, por favor hágamelo saber por qué

Answer 5

creo que la mejor manera es utilizar la corriente de cuerdas. simple y rápido!

ifstream inFile; 
inFile.open(inFileName);//open the input file 

stringstream strStream; 
strStream << inFile.rdbuf();//read the file 
string str = strStream.str();//str holds the content of the file 

cout << str << endl;//you can do anything with the string!!! 

Answer 6

Me di cuenta de otra manera que funciona con la mayoría de las corrientes isotérmicas, incluida std :: cin!

std::string readFile() 
{ 
stringstream str; 
ifstream stream("Hello_World.txt"); 
if(stream.is_open()) 
{ 
    while(stream.peek() != EOF) 
    { 
     str << (char) stream.get(); 
    } 
    stream.close(); 
    return str.str(); 
} 
} 

Answer 7

Pruebe uno de estos dos métodos:

string get_file_string(){ 
    std::ifstream ifs("path_to_file"); 
    return string((std::istreambuf_iterator<char>(ifs)), 
        (std::istreambuf_iterator<char>())); 
} 

string get_file_string2(){ 
    ifstream inFile; 
    inFile.open("path_to_file");//open the input file 

    stringstream strStream; 
    strStream << inFile.rdbuf();//read the file 
    return strStream.str();//str holds the content of the file 
} 

Answer 8

Es posible que no encontrará en cualquier libro o sitio, pero descubrí que funciona bastante bien:

ifstream ifs ("filename.txt"); 
string s; 
getline (ifs, s, (char) ifs.eof()); 

Answer 9

Si Si usa glibmm puede probar Glib::file_get_contents.

#include <iostream> 
#include <glibmm.h> 

int main() { 
    auto filename = "my-file.txt"; 
    try { 
     std::string contents = Glib::file_get_contents(filename); 
     std::cout << "File data:\n" << contents << std::endl; 
    catch (const Glib::FileError& e) { 
     std::cout << "Oops, an error occurred:\n" << e.what() << std::endl; 
    } 

    return 0; 
}