¿Cómo leo un archivo completo en una cadena std :: en C ++?

¿Cómo leo un archivo en un archivo std::string, es decir, leo todo el archivo a la vez?

El llamador debe especificar el modo de texto o binario. La solución debe cumplir con los estándares, ser portátil y eficiente. No debe copiar innecesariamente los datos de la cadena, y debe evitar reasignaciones de memoria mientras lee la cadena.

Una forma de hacer esto sería crear el tamaño del archivo, cambiar el tamaño std::stringy fread()el std::string's const_cast<char*>()' ed data(). Esto requiere que los std::stringdatos sean contiguos, lo cual no es requerido por el estándar, pero parece ser el caso para todas las implementaciones conocidas. Lo que es peor, si el archivo se lee en modo texto, el std::stringtamaño del archivo puede no ser igual al tamaño del archivo.

Se podrían construir soluciones portátiles totalmente correctas, que cumplan con los estándares, utilizando std::ifstream's rdbuf()en ay std::ostringstreamdesde allí en a std::string. Sin embargo, esto podría copiar los datos de la cadena y / o reasignar innecesariamente la memoria.

• ¿Son todas las implementaciones de biblioteca estándar relevantes lo suficientemente inteligentes como para evitar toda sobrecarga innecesaria?
• ¿Hay otra forma de hacerlo?
• ¿Perdí alguna función oculta de Boost que ya proporciona la funcionalidad deseada?

void slurp(std::string& data, bool is_binary)

Una forma es vaciar el búfer de flujo en un flujo de memoria separado y luego convertirlo a std::string:

std::string slurp(std::ifstream& in) {
    std::ostringstream sstr;
    sstr << in.rdbuf();
    return sstr.str();
}

Esto es muy conciso. Sin embargo, como se señaló en la pregunta, esto realiza una copia redundante y desafortunadamente no hay forma fundamental de eludir esta copia.

Lamentablemente, la única solución real que evita las copias redundantes es hacer la lectura manualmente en un bucle. Dado que C ++ ahora tiene cadenas contiguas garantizadas, se podría escribir lo siguiente (≥C ++ 14):

auto read_file(std::string_view path) -> std::string {
    constexpr auto read_size = std::size_t{4096};
    auto stream = std::ifstream{path.data()};
    stream.exceptions(std::ios_base::badbit);

    auto out = std::string{};
    auto buf = std::string(read_size, '\0');
    while (stream.read(& buf[0], read_size)) {
        out.append(buf, 0, stream.gcount());
    }
    out.append(buf, 0, stream.gcount());
    return out;
}

Vea esta respuesta en una pregunta similar.

Para su comodidad, estoy volviendo a publicar la solución de CTT:

string readFile2(const string &fileName)
{
    ifstream ifs(fileName.c_str(), ios::in | ios::binary | ios::ate);

    ifstream::pos_type fileSize = ifs.tellg();
    ifs.seekg(0, ios::beg);

    vector<char> bytes(fileSize);
    ifs.read(bytes.data(), fileSize);

    return string(bytes.data(), fileSize);
}

Esta solución resultó en tiempos de ejecución aproximadamente un 20% más rápidos que las otras respuestas presentadas aquí, al tomar el promedio de 100 ejecuciones contra el texto de Moby Dick (1.3M). No está mal para una solución portátil de C ++, me gustaría ver los resultados de mmap'ing el archivo;)

La variante más corta: Live On Coliru

std::string str(std::istreambuf_iterator<char>{ifs}, {});

Requiere el encabezado <iterator>.

Hubo algunos informes de que este método es más lento que preasignar la cadena y usarla std::istream::read. Sin embargo, en un compilador moderno con optimizaciones habilitadas, este ya no parece ser el caso, aunque el rendimiento relativo de varios métodos parece ser altamente dependiente del compilador.

Utilizar

#include <iostream>
#include <sstream>
#include <fstream>

int main()
{
  std::ifstream input("file.txt");
  std::stringstream sstr;

  while(input >> sstr.rdbuf());

  std::cout << sstr.str() << std::endl;
}

o algo muy cercano. No tengo una referencia stdlib abierta para verificar dos veces.

Sí, entiendo que no escribí la slurpfunción como se me pidió.

Si tiene C ++ 17 (std :: filesystem), también existe de esta manera (que obtiene el tamaño del archivo en std::filesystem::file_sizelugar de seekgy tellg):

#include <filesystem>
#include <fstream>
#include <string>

namespace fs = std::filesystem;

std::string readFile(fs::path path)
{
    // Open the stream to 'lock' the file.
    std::ifstream f(path, std::ios::in | std::ios::binary);

    // Obtain the size of the file.
    const auto sz = fs::file_size(path);

    // Create a buffer.
    std::string result(sz, '\0');

    // Read the whole file into the buffer.
    f.read(result.data(), sz);

    return result;
}

Nota : es posible que necesite usar <experimental/filesystem>y std::experimental::filesystemsi su biblioteca estándar aún no es totalmente compatible con C ++ 17. También podría ser necesario reemplazar result.data()con &result[0]si no soporta std :: basic_string datos no const .

No tengo suficiente reputación para comentar directamente sobre las respuestas que utilizo tellg().

Tenga en cuenta que tellg()puede devolver -1 en caso de error. Si pasa el resultado tellg()como un parámetro de asignación, primero debe verificar el resultado.

Un ejemplo del problema:

...
std::streamsize size = file.tellg();
std::vector<char> buffer(size);
...

En el ejemplo anterior, si tellg() encuentra un error, devolverá -1. La conversión implícita entre firmado (es decir, el resultado de tellg()) y sin signo (es decir, el arg al vector<char>constructor) se traducirá en un su vector erróneamente la asignación de una muy gran número de bytes. (Probablemente 4294967295 bytes, o 4GB.)

Modificando la respuesta de paxos1977 para tener en cuenta lo anterior:

string readFile2(const string &fileName)
{
    ifstream ifs(fileName.c_str(), ios::in | ios::binary | ios::ate);

    ifstream::pos_type fileSize = ifs.tellg();
    if (fileSize < 0)                             <--- ADDED
        return std::string();                     <--- ADDED

    ifs.seekg(0, ios::beg);

    vector<char> bytes(fileSize);
    ifs.read(&bytes[0], fileSize);

    return string(&bytes[0], fileSize);
}

Esta solución agrega verificación de errores al método basado en rdbuf ().

std::string file_to_string(const std::string& file_name)
{
    std::ifstream file_stream{file_name};

    if (file_stream.fail())
    {
        // Error opening file.
    }

    std::ostringstream str_stream{};
    file_stream >> str_stream.rdbuf();  // NOT str_stream << file_stream.rdbuf()

    if (file_stream.fail() && !file_stream.eof())
    {
        // Error reading file.
    }

    return str_stream.str();
}

Estoy agregando esta respuesta porque agregar la comprobación de errores al método original no es tan trivial como cabría esperar. El método original utiliza el operador de inserción de stringstream (str_stream << file_stream.rdbuf() ). El problema es que esto establece el bitbit de secuencia de cadena cuando no se insertan caracteres. Eso puede ser debido a un error o puede ser debido a que el archivo está vacío. Si verifica si hay fallas al inspeccionar el bit de falla, encontrará un falso positivo cuando lea un archivo vacío. ¿Cómo desambigua la falla legítima para insertar caracteres y la "falla" para insertar caracteres porque el archivo está vacío?

Puede pensar en buscar explícitamente un archivo vacío, pero eso es más código y verificación de errores asociados.

La comprobación de la condición de falla str_stream.fail() && !str_stream.eof()no funciona, porque la operación de inserción no establece el eofbit (en el ostringstream ni en el ifstream).

Entonces, la solución es cambiar la operación. En lugar de usar el operador de inserción de ostringstream (<<), use el operador de extracción de ifstream (>>), que establece el eofbit. Luego verifique la condición de falla file_stream.fail() && !file_stream.eof().

Es importante destacar que, cuando se file_stream >> str_stream.rdbuf()encuentra con una falla legítima, nunca debería establecer eofbit (de acuerdo con mi comprensión de la especificación). Eso significa que la verificación anterior es suficiente para detectar fallas legítimas.

Algo como esto no debería ser tan malo:

void slurp(std::string& data, const std::string& filename, bool is_binary)
{
    std::ios_base::openmode openmode = ios::ate | ios::in;
    if (is_binary)
        openmode |= ios::binary;
    ifstream file(filename.c_str(), openmode);
    data.clear();
    data.reserve(file.tellg());
    file.seekg(0, ios::beg);
    data.append(istreambuf_iterator<char>(file.rdbuf()), 
                istreambuf_iterator<char>());
}

La ventaja aquí es que hacemos la reserva primero para no tener que hacer crecer la cadena mientras leemos las cosas. La desventaja es que lo hacemos char por char. Una versión más inteligente podría tomar todo el buf de lectura y luego llamar al flujo inferior.

Aquí hay una versión que usa la nueva biblioteca del sistema de archivos con una comprobación de errores razonablemente robusta:

#include <cstdint>
#include <exception>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <string>

namespace fs = std::filesystem;

std::string loadFile(const char *const name);
std::string loadFile(const std::string &name);

std::string loadFile(const char *const name) {
  fs::path filepath(fs::absolute(fs::path(name)));

  std::uintmax_t fsize;

  if (fs::exists(filepath)) {
    fsize = fs::file_size(filepath);
  } else {
    throw(std::invalid_argument("File not found: " + filepath.string()));
  }

  std::ifstream infile;
  infile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
  try {
    infile.open(filepath.c_str(), std::ios::in | std::ifstream::binary);
  } catch (...) {
    std::throw_with_nested(std::runtime_error("Can't open input file " + filepath.string()));
  }

  std::string fileStr;

  try {
    fileStr.resize(fsize);
  } catch (...) {
    std::stringstream err;
    err << "Can't resize to " << fsize << " bytes";
    std::throw_with_nested(std::runtime_error(err.str()));
  }

  infile.read(fileStr.data(), fsize);
  infile.close();

  return fileStr;
}

std::string loadFile(const std::string &name) { return loadFile(name.c_str()); };

Puede usar la función 'std :: getline' y especificar 'eof' como delimitador. Sin embargo, el código resultante es un poco oscuro:

std::string data;
std::ifstream in( "test.txt" );
std::getline( in, data, std::string::traits_type::to_char_type( 
                  std::string::traits_type::eof() ) );

Nunca escriba en el buffer stst :: string's const char *. ¡Nunca jamás! Hacerlo es un gran error.

Reserve () espacio para toda la cadena en su std :: string, lea fragmentos de su archivo de tamaño razonable en un búfer y añádalo (). El tamaño que deben tener los fragmentos depende del tamaño del archivo de entrada. Estoy bastante seguro de que todos los demás mecanismos portátiles y compatibles con STL harán lo mismo (aunque pueden parecer más bonitos).

#include <string>
#include <sstream>

using namespace std;

string GetStreamAsString(const istream& in)
{
    stringstream out;
    out << in.rdbuf();
    return out.str();
}

string GetFileAsString(static string& filePath)
{
    ifstream stream;
    try
    {
        // Set to throw on failure
        stream.exceptions(fstream::failbit | fstream::badbit);
        stream.open(filePath);
    }
    catch (system_error& error)
    {
        cerr << "Failed to open '" << filePath << "'\n" << error.code().message() << endl;
        return "Open fail";
    }

    return GetStreamAsString(stream);
}

uso:

const string logAsString = GetFileAsString(logFilePath);

Una función actualizada que se basa en la solución de CTT:

#include <string>
#include <fstream>
#include <limits>
#include <string_view>
std::string readfile(const std::string_view path, bool binaryMode = true)
{
    std::ios::openmode openmode = std::ios::in;
    if(binaryMode)
    {
        openmode |= std::ios::binary;
    }
    std::ifstream ifs(path.data(), openmode);
    ifs.ignore(std::numeric_limits<std::streamsize>::max());
    std::string data(ifs.gcount(), 0);
    ifs.seekg(0);
    ifs.read(data.data(), data.size());
    return data;
}

Hay dos diferencias importantes:

tellg()no se garantiza que devuelva el desplazamiento en bytes desde el comienzo del archivo. En cambio, como señaló Puzomor Croacia, es más un token que se puede usar dentro de las llamadas de fstream. gcount()sin embargo , devuelve la cantidad de bytes sin formato extraídos por última vez. Por lo tanto, abrimos el archivo, extraemos y descartamos todo su contenido conignore() para obtener el tamaño del archivo, y construimos la cadena de salida en función de eso.

En segundo lugar, evitamos tener que copiar los datos del archivo de un std::vector<char>a unstd::string escribiendo directamente en la cadena.

En términos de rendimiento, este debería ser el más rápido absoluto, asignando la cadena del tamaño apropiado con anticipación y llamando read()una vez. Como dato interesante, usar ignore()y en countg()lugar de atey tellg()en gcc se compila casi a la misma cosa , poco a poco.

#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
main(){
    fstream file;
    file.open("test.txt");
    string copy,temp;
    while(getline(file,temp)){
        copy+=temp;
        copy+="\n";
    }
    cout<<copy;
    file.close();
}