Lire le contenu du fichier dans une chaîne en C ++

Question

Dupliquer possible:
Quel est le meilleur moyen de transformer un fichier en std :: string en c ++?

Dans les langages de script tels que Perl, il est possible de lire un fichier dans une variable d'un coup.

     open(FILEHANDLE,$file);
    $content=<FILEHANDLE>;
 

Quel serait le moyen le plus efficace de faire cela en C ++?

Answer 1

Comme ça:

 #include <fstream>
#include <string>

int main(int argc, char** argv)
{

  std::ifstream ifs("myfile.txt");
  std::string content( (std::istreambuf_iterator<char>(ifs) ),
                       (std::istreambuf_iterator<char>()    ) );

  return 0;
}
 

La déclaration

   std::string content( (std::istreambuf_iterator<char>(ifs) ),
                       (std::istreambuf_iterator<char>()    ) );
 

peut être divisé en

 std::string content;
content.assign( (std::istreambuf_iterator<char>(ifs) ),
                (std::istreambuf_iterator<char>()    ) );
 

ce qui est utile si vous voulez simplement écraser la valeur d'une variable std :: string existante.

Answer 2

Le plus efficace, mais pas le C++ serait:

   FILE* f = fopen(filename, "r");

   // Determine file size
   fseek(f, 0, SEEK_END);
   size_t size = ftell(f);

   char* where = new char[size];

   rewind(f);
   fread(where, sizeof(char), size, f);

   delete[] where;

#EDITION - 2

Juste testé l' std::filebuf variante. Ressemble peut être appelé le meilleur C++ approche, même si ce n'est pas tout à fait en C++, mais plus d'un wrapper. De toute façon, voici le morceau de code qui fonctionne presque aussi rapide que du C ne.

   std::ifstream file(filename, std::ios::binary);
   std::streambuf* raw_buffer = file.rdbuf();

   char* block = new char[size];
   raw_buffer->sgetn(block, size);
   delete[] block;

J'ai fait un rapide test ici, et les résultats sont les suivants. Le Test a été fait sur la lecture d'une 65536K fichier binaire approprié (std::ios:binary et rb) modes de fonctionnement.

[==========] Running 3 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 4 tests from IO
[ RUN      ] IO.C_Kotti
[       OK ] IO.C_Kotti (78 ms)
[ RUN      ] IO.CPP_Nikko
[       OK ] IO.CPP_Nikko (106 ms)
[ RUN      ] IO.CPP_Beckmann
[       OK ] IO.CPP_Beckmann (1891 ms)
[ RUN      ] IO.CPP_Neil
[       OK ] IO.CPP_Neil (234 ms)
[----------] 4 tests from IO (2309 ms total)

[----------] Global test environment tear-down
[==========] 4 tests from 1 test case ran. (2309 ms total)
[  PASSED  ] 4 tests.

Answer 3

Le plus efficace est de créer un tampon de la taille correcte, puis de lire le fichier dans le tampon.

 #include <fstream>
#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.
         * Because char is a POD data type it is not initialized.
         *
         * Then read the whole file into the buffer.
         */
        std::vector<char>       buffer(length);
        file.read(&buffer[0],length);
    }
}
 

Answer 4

Il ne devrait y avoir aucun \0 dans les fichiers texte.

 #include<iostream>
#include<fstream>

using namespace std;

int main(){
  fstream f(FILENAME, fstream::in );
  string s;
  getline( f, s, '\0');

  cout << s << endl;
  f.close();
}