Odczyt całego pliku ASCII do C++ std:: string [duplikat]

Jest kilka możliwości. Ten, który lubię, używa stringstream jako pośrednika:

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

Teraz zawartość pliku.txt " są dostępne w postaci buffer.str().

Inna możliwość (choć na pewno mi się to nie podoba) jest o wiele bardziej podobna do Twojej oryginalnej:

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

Oficjalnie nie jest to wymagane do pracy w standardzie C++98 lub 03 (string nie jest wymagany do przechowywania danych w sposób ciągły), ale w rzeczywistości działa ze wszystkimi znanymi implementacjami, A C++11 i późniejsze wymagają ciągłego przechowywania, więc gwarantowana jest praca z nimi.

Co do tego, dlaczego nie lubię tego drugiego, jak również: po pierwsze, ponieważ jest dłuższy i trudniejszy do odczytania. Po drugie, ponieważ wymaga to inicjalizacji zawartości łańcucha z danymi, na których Ci nie zależy, a następnie natychmiastowego zapisania tych danych(TAK, Czas inicjalizacji jest zwykle trywialny w porównaniu do odczytu, więc prawdopodobnie nie ma to znaczenia, ale dla mnie nadal wydaje się to trochę złe). Po trzecie, w pliku tekstowym, pozycja X w plik nie musi oznaczać, że będziesz musiał czytać znaki X, aby osiągnąć ten punkt-nie jest wymagane, aby wziąć pod uwagę rzeczy, takie jak tłumaczenia końca linii. Na prawdziwych systemach, które wykonują takie tłumaczenia (np. Windows) przetłumaczona forma jest krótsza niż to, co jest w pliku (np. "\R\n" w pliku staje się "\n" w przetłumaczonym łańcuchu), więc wszystko, co zrobiłeś, jest zarezerwowane trochę dodatkowego miejsca, którego nigdy nie używasz. Ponownie, tak naprawdę nie powoduje większego problemu, ale i tak czuje się trochę źle.

Myślę, że najlepszym sposobem jest użycie string stream. prosto i szybko !!!

#include <fstream>
#include <iostream>
#include <sstream> //std::stringstream
int main() {
    std::ifstream inFile;
    inFile.open("inFileName"); //open the input file

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

    std::cout << str << "\n"; //you can do anything with the string!!!
}

Może nie znajdziesz tego w żadnej książce lub stronie, ale dowiedziałem się, że działa całkiem dobrze:

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

Wypróbuj jedną z tych dwóch metod:

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
}

Wymyśliłem inny sposób, który działa z większością strumieni, w tym 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();
    }
}

Jeśli zdarzy ci się użyć glibmm Możesz spróbować 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;
}

Mógłbym to zrobić tak:

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

Jeśli jest to coś, na co warto się pochylić, proszę daj mi znać dlaczego

Myślę, że nie można tego zrobić bez jawnej lub niejawnej pętli, bez wczytania do tablicy znaków (lub innego kontenera) najpierw i ten konstruując łańcuch. Jeśli nie potrzebujesz innych możliwości ciągu znaków, można to zrobić za pomocą vector<char> w ten sam sposób, w jaki obecnie używasz char *.