C++: write values to a file the easiest and cleanest way possible?

Question

I'm working on a C++ beginner level project (not absolute beginner like "what's a loop" but I wouldn't say it's intermediate level either).

In this project I need to save into a file some data stored in memory in struct variables (this is plain imperative programming, with no OOP involved).

I've read a bit about options like serialization, using some non-standard libraries and such. But I need to keep it as simple and clean as possible.

So far I have 2 structs, pretty much like these:

struct client {
    string name;
    string address;
    double phone;
};
struct invoice {
    string client_name;
    double total;
};

I'm looking for something like this example provided at http://www.cplusplus.com/doc/tutorial/files:

#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream myfile;
  myfile.open ("example.txt");
  myfile << "Writing this to a file.\n";
  myfile.close();
  return 0;
}

Is there a way to do something like that, but to write (and then be able to read) struct variables to a file, keeping it simple? Some years ago I remember handling this in a very simple way in Pascal, when writing records to files. It was something like: open file, write record field 1, write field separador, write record field 2, write field separator, write record separator. Then when reading I would search for separators. Is this not recommended in C++?

Thanks.

Answer 1

You could check serialization for C++, eg. Boost::serialization in the Boost library.

Is it possible to serialize and deserialize a class in C++?

Answer 2

You have to associate 2 functions to this class : inputStruct and OutputStruct. Input should be able to read what Output generate. The easy way consist in writing each struct element in the same order that they are implemented.

Answer 3

The clear way to do that is implementing a serialize and deserialize function for every structure or class that you want to write to a file. You give the serialize function the reference of the output stream, and it writes each of the fields that you want to write. The deserialize do the opposite: it reads all the properties in the same order, and sets them in the current class or structure. If you use the stream operators for serialization, the output file will be a text file.

With c++ you can overload stream operator, so it will look pretty in your code, but in other languages you must use functions for that.

You can also use binary serialization, but it is more problematic, because you need to check the endianness of the platform that you use currently. If you will just use it on one platform, you can try write, and read functions. They need the pointer of the variable, and the size, and they copy them into/from the file. Use these for every property separate, never copy whole structures, because it can lead to errors easily.

UPDATE:

I made serialize and deserialize functions. I haven't tested them, so im not 100% sure they will work.

Static functions:

void serialize_client( ofstream& out, client& cl )
{
    out << cl.name << endl;
    out << cl.address << endl;
    out << cl.phone << endl;
}

void deserialize_client( ifstream& in, client& cl )
{
    getline( in, cl.name );
    getline( in, cl.address );
    in >> cl.phone;    
}

Usage:

client client_instance;
deserialize_client( cin, client_instance );   
serialize_client( cout,  client_instance );

With operator overload:

ostream& operator<<( ostream& os, const client& cl )
{
    os << cl.name << endl;
    os << cl.address << endl;
    os << cl.phone << endl;
    return os;
}

istream& operator>>( istream& is, client& cl )
{
    getlise( is, cl.name );
    getlise( is, cl.address );
    is >> cl.phone; 
    return is;
}

client client_instance;
cin >> client_instance;   
cout << client_instance;