#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <string>
#include <fstream>

class A{
private:
	friend class boost::serialization::access;

	template<class Archive>
	void serialize(Archive & ar, const unsigned int version)
	{
		ar & a_;
	}

	int a_;

public:
	A(){ std::cout << "A constructed" << std::endl; }
	A(int a): a_(a) { std::cout << "A constructed with 'a' ==" << a << std::endl; }
};
class B{
private:
	friend class boost::serialization::access;

	template<class Archive>
	void serialize(Archive & ar, const unsigned int version)
	{
		ar & b_;
	}

	std::string b_;
public:
	B(){ std::cout << "B constructed" << std::endl; }
	B(std::string b): b_(b) { std::cout << "B constructed with 'b' ==" << b << std::endl; }
};

class C{
private:
	friend class boost::serialization::access;

	template<class Archive>
	void serialize(Archive & ar, const unsigned int version)
	{
		ar & a_;
		ar & b_;
		ar & d_;
	}

	A a_;
	B b_;
	double d_;

public:
	C(){  std::cout << "C constructed" << std::endl; }
	C(int a, std::string b, double d ): a_(a), b_(b), d_(d) { std::cout << "C constructed with 'd' == " << d << std::endl; }
};

int main() {
	// create and open a character archive for output
	std::ofstream ofs("filename");

	// create class instance
	C c(15, "rock and roll", 25.8);

	// save data to archive
	{
		boost::archive::text_oarchive oa(ofs);
		// write class instance to archive
		oa << c;
		// archive and stream closed when destructors are called
	}

	C c_recreated;
	{
		// create and open an archive for input
		std::ifstream ifs("filename");
		boost::archive::text_iarchive ia(ifs);
		// read class state from archive
		ia >> c_recreated;
		// archive and stream closed when destructors are called
	}

	std::cin.get();
}