Comment lire un fichier entier dans une chaîne std :: string en C ++?

Comment puis-je lire un fichier dans un std::string, c'est-à-dire lire le fichier entier à la fois?

Le mode texte ou binaire doit être spécifié par l'appelant. La solution doit être conforme aux normes, portable et efficace. Il ne doit pas copier inutilement les données de la chaîne et il doit éviter les réallocations de mémoire lors de la lecture de la chaîne.

Une façon de faire serait de statuer la taille du fichier, de redimensionner le std::stringet fread()dans le std::string's const_cast<char*>()' ed data(). Cela nécessite que les std::stringdonnées s soient contiguës, ce qui n'est pas requis par la norme, mais cela semble être le cas pour toutes les implémentations connues. Pire encore, si le fichier est lu en mode texte, la std::stringtaille du fichier peut ne pas être égale à la taille du fichier.

Des solutions entièrement correctes, conformes aux normes et portables pourraient être construites en utilisant std::ifstreamdes rdbuf()dans un std::ostringstreamet de là dans un std::string. Cependant, cela pourrait copier les données de chaîne et / ou réallouer inutilement de la mémoire.

• Toutes les implémentations de bibliothèques standard pertinentes sont-elles suffisamment intelligentes pour éviter toute surcharge inutile?
• Y a-t-il une autre façon de le faire?
• Ai-je manqué une fonction Boost cachée qui fournit déjà la fonctionnalité souhaitée?

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

Une façon consiste à vider le tampon de flux dans un flux de mémoire séparé, puis à le convertir en std::string:

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

C'est très concis. Cependant, comme indiqué dans la question, cela effectue une copie redondante et, malheureusement, il n'y a fondamentalement aucun moyen d'éliminer cette copie.

La seule vraie solution qui évite les copies redondantes est de faire la lecture manuellement en boucle, malheureusement. Puisque C ++ a maintenant garanti des chaînes contiguës, on pourrait écrire ce qui suit (≥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;
}

Voir cette réponse sur une question similaire.

Pour votre commodité, je republie la solution 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);
}

Cette solution a entraîné des temps d'exécution environ 20% plus rapides que les autres réponses présentées ici, en prenant la moyenne de 100 courses contre le texte de Moby Dick (1,3M). Pas mal pour une solution C ++ portable, j'aimerais voir les résultats de la mmap'ing du fichier;)

La variante la plus courte: Live On Coliru

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

Il nécessite l'en-tête <iterator>.

Certains rapports indiquent que cette méthode est plus lente que la pré-allocation de la chaîne et l'utilisation de std::istream::read. Cependant, sur un compilateur moderne avec des optimisations activées, cela ne semble plus être le cas, bien que les performances relatives de diverses méthodes semblent dépendre fortement du compilateur.

Utilisation

#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;
}

ou quelque chose de très proche. Je n'ai pas de référence stdlib ouverte pour me vérifier moi-même.

Oui, je comprends que je n'ai pas écrit la slurpfonction comme demandé.

Si vous avez C ++ 17 (std :: filesystem), il existe également cette méthode (qui récupère la taille du fichier au std::filesystem::file_sizelieu de seekget 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;
}

Remarque : vous devrez peut-être utiliser <experimental/filesystem>et std::experimental::filesystemsi votre bibliothèque standard ne prend pas encore entièrement en charge C ++ 17. Vous devrez peut-être également le remplacer result.data()par &result[0]s'il ne prend pas en charge les données std :: basic_string non const .

Je n'ai pas assez de réputation pour commenter directement les réponses utilisant tellg().

Veuillez noter que tellg()peut renvoyer -1 en cas d'erreur. Si vous transmettez le résultat de en tellg()tant que paramètre d'allocation, vous devez d'abord vérifier le résultat.

Un exemple du problème:

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

Dans l'exemple ci-dessus, si tellg()une erreur se produit, il renverra -1. Le transtypage implicite entre signé (c'est-à-dire le résultat de tellg()) et non signé (c'est-à-dire l'argument du vector<char>constructeur) se traduira par une allocation erronée par votre vecteur d'un très grand nombre d'octets. (Probablement 4294967295 octets, soit 4 Go.)

Modification de la réponse de paxos1977 pour tenir compte de ce qui précède:

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);
}

Cette solution ajoute la vérification des erreurs à la méthode basée sur 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();
}

J'ajoute cette réponse car l'ajout de la vérification des erreurs à la méthode d'origine n'est pas aussi trivial que prévu. La méthode d'origine utilise l'opérateur d'insertion de stringstream ( str_stream << file_stream.rdbuf()). Le problème est que cela définit le failbit du flux de chaînes lorsqu'aucun caractère n'est inséré. Cela peut être dû à une erreur ou au fait que le fichier est vide. Si vous recherchez des échecs en inspectant le failbit, vous rencontrerez un faux positif lorsque vous lirez un fichier vide. Comment dissiper toute ambiguïté légitime de l'échec d'insertion de caractères et «échec» d'insérer des caractères parce que le fichier est vide?

Vous pourriez penser à rechercher explicitement un fichier vide, mais c'est plus de code et de vérification d'erreur associée.

La vérification de la condition d'échec str_stream.fail() && !str_stream.eof()ne fonctionne pas, car l'opération d'insertion ne définit pas l'eofbit (sur l'ostringstream ni sur l'ifstream).

Donc, la solution est de changer l'opération. Au lieu d'utiliser l'opérateur d'insertion d'ostringstream (<<), utilisez l'opérateur d'extraction d'ifstream (>>), qui définit l'eofbit. Vérifiez ensuite la condition d'échec file_stream.fail() && !file_stream.eof().

Surtout, lorsque file_stream >> str_stream.rdbuf()rencontre un échec légitime, il ne devrait jamais définir eofbit (selon ma compréhension de la spécification). Cela signifie que la vérification ci-dessus est suffisante pour détecter les échecs légitimes.

Quelque chose comme ça ne devrait pas être trop grave:

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>());
}

L'avantage ici est que nous faisons la réserve en premier afin de ne pas avoir à agrandir la chaîne pendant que nous lisons les choses. L'inconvénient est que nous le faisons char par char. Une version plus intelligente pourrait récupérer tout le buf de lecture, puis appeler underflow.

Voici une version utilisant la nouvelle bibliothèque de système de fichiers avec une vérification d'erreur raisonnablement robuste:

#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()); };

Vous pouvez utiliser la fonction 'std :: getline' et spécifier 'eof' comme délimiteur. Le code qui en résulte est cependant un peu obscur:

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

N'écrivez jamais dans le tampon const char * de std :: string. Plus jamais! Cela est une énorme erreur.

Réservez () de l'espace pour toute la chaîne de votre std :: string, lisez des morceaux de votre fichier de taille raisonnable dans un tampon et ajoutez-le (). La taille des morceaux dépend de la taille de votre fichier d'entrée. Je suis presque sûr que tous les autres mécanismes portables et compatibles STL feront de même (mais peuvent paraître plus jolis).

#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);
}

usage:

const string logAsString = GetFileAsString(logFilePath);

Une fonction mise à jour qui s'appuie sur la solution 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;
}

Il existe deux différences importantes:

tellg()n'est pas garanti de renvoyer le décalage en octets depuis le début du fichier. Au lieu de cela, comme l'a souligné Puzomor Croatia, il s'agit davantage d'un jeton qui peut être utilisé dans les appels fstream.gcount()cependant le fait revenir la quantité d'octets non formatés dernier extrait. Nous ouvrons donc le fichier, extrayons et supprimons tout son contenu avecignore() pour obtenir la taille du fichier, et construisons la chaîne de sortie en fonction de cela.

Deuxièmement, nous évitons d'avoir à copier les données du fichier d'un std::vector<char>vers unstd::string en écrivant directement dans la chaîne.

En termes de performances, cela devrait être le plus rapide absolu, en allouant la chaîne de taille appropriée à l'avance et en appelant read()une fois. Fait intéressant, utiliser ignore()et countg()au lieu de ateet tellg()sur gcc se compile à peu près à la même chose , petit à petit.

#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();
}