Difference between revisions of "cpp/io/basic fstream"

#include <iostream>
#include <fstream>
#include <limits>
#include <string>
 
struct Birthday { long day, month, year; };
 
class Entry {
    std::string name;
    Birthday bday;
public:
    Entry(std::string name_, long day_, long month_, long year_) : 
        name(name_), bday({day_, month_, year_}) {}
    void printToStdOut() { 
        std::cout << name << ' ' << bday.day << '/' << bday.month << '/'
                  << bday.year << '\n';
    }
    //name and bday are private so we must make << and >> friends of the class
    friend std::ostream &operator<<(std::ostream &, Entry &);
    friend std::istream &operator>>(std::istream &, Entry &);
};
 
std::ostream &operator<<(std::ostream &strm, Entry &e) {
    //Since the length of e.name is not necessarily known at compile time, we
    // can't simply use: strm.write(reinterpret_cast<char*>(&e), sizeof e);
    unsigned int length = e.name.length();
    strm.write(reinterpret_cast<char*>(&length), sizeof length);
    strm.write(&e.name[0], length);
    strm.write(reinterpret_cast<char*>(&e.bday), sizeof e.bday);
    return strm;
}
 
std::istream &operator>>(std::istream &strm, Entry &e) {
    unsigned int length;
    strm.read(reinterpret_cast<char*>(&length), sizeof length);
    e.name.resize(length);
    strm.read(&e.name[0], length);
    strm.read(reinterpret_cast<char*>(&e.bday), sizeof e.bday);
    return strm;
}
 
int main() {
    Entry e("Alpha", 1, 1, -13820000000);
    e.printToStdOut();
 
    std::string filename = "Test.b";
    std::ofstream ostrm;
    //Open the file or else create it
    ostrm.open(filename, std::fstream::binary);
    if(!ostrm.is_open()) {
        ostrm.clear();
        ostrm.open(filename, std::fstream::out);  //Create the file
        ostrm.close();
        ostrm.open(filename, std::fstream::binary);
        if(!ostrm.good())
            return 1;
    }
 
    //write the Entry e to the file
    ostrm << e;
    ostrm.close();
 
    Entry e_recovered("Omega", 31, 12, std::numeric_limits<long>::max());
    e_recovered.printToStdOut();
 
    //Open the file for reading
    std::ifstream istrm;
    istrm.open(filename, std::fstream::binary);
    if(!istrm.good())
        return 1;
 
    //overwrite e_recovered with the values from istrm
    istrm >> e_recovered;
    istrm.close();
 
    e_recovered.printToStdOut();
    return 0;
}