serialization

gistfile1.cpp

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
 
// Only for POD types
template <class T>
void serialize(T& obj, std::ostream& out)
{
        //size_t s = sizeof(obj);
        //out.write(&s, sizeof(size_t));
        //out.write(&obj, s);
        out.write(reinterpret_cast<char*>(&obj), sizeof(obj));
}
 
template <class T>
void deserialize(T &obj, std::istream& in)
{
        in.read(reinterpret_cast<char*>(&obj), sizeof(obj));
}
 
 
// for Vectors
template <class T>
void serialize(std::vector<T>& obj, std::ostream& out)
{
        size_t size = obj.size();
        out.write(reinterpret_cast<char*> (&size), sizeof(size_t));
       
        for (size_t i = 0; i < obj.size(); ++i)
                serialize(obj[i], out);
}
 
template <class T>
void deserialize(std::vector<T>& obj, std::istream& in)
{
        size_t size;
        in.read(reinterpret_cast<char*>(&size), sizeof(size_t));
       
        obj.clear();
        obj.resize(size);
       
        for (size_t i = 0; i < size; ++i)
                deserialize(obj[i], in);
}
 
//for Strings
void serialize(std::string obj, std::ostream& out)
{
        size_t size = obj.length();
        out.write(reinterpret_cast<char*>(&size), sizeof(size_t));
 
        out.write(obj.c_str(), size);  
}
 
void deserialize(std::string obj, std::istream& in)
{
        size_t size;
        in.read(reinterpret_cast<char*>(&size), sizeof(size_t));
       
        char *data = new char[size + 1];
       
        in.read(data, size);
        obj.assign(data, size);
       
        delete [] data;
}
 
int main()
{
        int a = 123;
        double b = 12.45;
 
        std::vector<std::vector<std::string> > v;
        std::vector<std::string> v1, v2, v3;
       
        std::string test1 = "HeyHeyHey!";
        std::string test2 = "I'm stupid string!";
        std::string test3 = "ПыщьПыщь!";
       
        v1.push_back(test1);
        v1.push_back(test2);
        v1.push_back(test3);
       
        v2.push_back(test2);
        v2.push_back(test3);
        v2.push_back(test1);
       
        v3.push_back(test3);
        v3.push_back(test1);
        v3.push_back(test2);
       
        v.push_back(v1);
        v.push_back(v2);
        v.push_back(v3);
       
        std::ofstream f("tempfile", std::ios::binary);
       
        serialize(a, f);
        serialize(b, f);
        serialize(v, f);
       
        f.close();
       
        int ra;
        double rb;
       
        std::vector<std::vector<std::string> > res;
       
        std::ifstream ff("tempfile", std::ios::binary);
       
        deserialize(ra, ff);
        deserialize(rb, ff);
       
        //std::cout << ra << " " << rb;
        deserialize(res, ff);
       
        std::cout << "{" << std::endl;
        std::cout << v[0][0] << " " << v[0][1] << " " << v[0][2] << std::endl;
        std::cout << v[1][0] << " " << v[1][1] << " " << v[1][2] << std::endl;
        std::cout << v[2][0] << " " << v[2][1] << " " << v[2][2] << std::endl;
        std::cout << "}" << std::endl;
       
        f.close();     
 
        return 0;
}