Lire tout le fichier ASCII dans std :: string C ++

Question

Je dois lire un fichier entier en mémoire et le placer dans un std::string en C++.

Si je devais le lire dans un char[], la réponse serait très simple:

std::ifstream t;
int length;
t.open("file.txt");      // ouvrir le fichier d'entrée
t.seekg(0, std::ios::end);    // aller à la fin
length = t.tellg();           // indiquer l'emplacement (c'est la longueur)
t.seekg(0, std::ios::beg);    // revenir au début
buffer = new char[length];    // allouer de la mémoire pour un tampon de la dimension appropriée
t.read(buffer, length);       // lire le fichier entier dans le tampon
t.close();                    // fermer la poignée du fichier

// ... Faire des trucs avec le tampon ici ...

Maintenant, je veux faire exactement la même chose, mais en utilisant un std::string au lieu d'un char[]. Je veux éviter les boucles, c'est-à-dire que je ne veux pas:

std::ifstream t;
t.open("file.txt");
std::string buffer;
std::string line;
while(t){
std::getline(t, line);
// ... Ajoutez la ligne au tampon et continuez
}
t.close()

Des idées?

Answer 1

Il existe quelques possibilités. Celle que j'aime utilise un stringstream comme intermédiaire :

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

Maintenant, le contenu de "file.txt" est disponible dans une chaîne de caractères comme buffer.str().

Une autre possibilité (bien que je ne l'aime certainement pas autant) est beaucoup plus similaire à votre solution d'origine :

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

Officiellement, ce n'est pas nécessaire de fonctionner sous les normes C++98 ou 03 (il n'est pas nécessaire que la chaîne de caractères stocke les données de manière contiguë) mais en fait ça fonctionne avec toutes les implémentations connues, et C++11 et les versions ultérieures nécessitent un stockage contigu, donc c'est garanti pour fonctionner avec elles.

Quant à pourquoi je n'aime pas autant cette dernière solution : premièrement, parce que c'est plus long et plus difficile à lire. Deuxièmement, parce qu'il nécessite que vous initialisiez le contenu de la chaîne avec des données dont vous n'avez pas besoin, puis écrivez immédiatement sur ces données (oui, le temps d'initialisation est généralement négligeable par rapport à la lecture, donc cela ne pose probablement pas de problème, mais pour moi cela semble toujours un peu faux). Troisièmement, dans un fichier texte, la position X dans le fichier ne signifie pas nécessairement que vous aurez lu X caractères pour atteindre ce point - il n'est pas nécessaire de prendre en compte des éléments tels que les traductions de fin de ligne. Sur les systèmes réels qui effectuent de telles traductions (par exemple, Windows), la forme traduite est plus courte que ce qui se trouve dans le fichier (c'est-à-dire que "\r\n" dans le fichier devient "\n" dans la chaîne traduite) donc vous avez simplement réservé un peu d'espace supplémentaire que vous n'utiliserez jamais. Encore une fois, cela ne pose pas vraiment de problème majeur mais ça semble un peu faux quand même.

Answer 2

Mise à jour: Il s'avère que cette méthode, bien qu'elle suive bien les idiomes STL, est en fait étonnamment inefficace! Ne faites pas cela avec de gros fichiers. (Voir: http://insanecoding.blogspot.com/2011/11/how-to-read-in-file-in-c.html)

Vous pouvez créer un itérateur streambuf à partir du fichier et initialiser la chaîne avec celui-ci:

#include 
#include 
#include 

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

Je ne sais pas d'où vient la syntaxe t.open("file.txt", "r"). Autant que je sache, ce n'est pas une méthode que std::ifstream possède. On dirait que vous l'avez confondue avec fopen de C.

Édition: Notez également les parenthèses supplémentaires autour du premier argument du constructeur de la chaîne. Elles sont essentielles. Elles évitent le problème connu sous le nom de "analyse la plus contrariante", qui, dans ce cas, ne vous donnera pas réellement une erreur de compilation comme c'est généralement le cas, mais vous donnera des résultats intéressants (à savoir: incorrects).

Suivant le point de KeithB dans les commentaires, voici une façon de le faire qui alloue toute la mémoire à l'avance (plutôt que de compter sur la réallocation automatique de la classe string):

#include 
#include 
#include 

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(t)),
            std::istreambuf_iterator());

Answer 3

Je pense que la meilleure façon est d'utiliser un flux de chaînes. Simple et rapide !!!

#include <fstream>
#include <iostream>
#include <sstream> //std::stringstream
int main() {
    std::ifstream inFile;
    inFile.open("inFileName"); //ouvrir le fichier d'entrée

    std::stringstream strStream;
    strStream << inFile.rdbuf(); //lire le fichier
    std::string str = strStream.str(); //str contient le contenu du fichier

    std::cout << str << "\n"; //vous pouvez faire ce que vous voulez avec la chaîne !!!
}

Answer 4

J'ai trouvé une autre méthode qui fonctionne avec la plupart des istreams, y compris 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 5

Je pourrais le faire de cette manière :

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

Si c'est quelque chose qui doit être désapprouvé, veuillez me faire savoir pourquoi