Not able to serialize data properly using boost

Question

I am very new to Serialization and i am trying to use boost to serialize my data.

This is dummy code of what i intend to do.

I am using Geometry class as interface for other classes like Sphere , Rectangle etc.

The issue i have is this line "c_Restored->PrintContainer();" should call the Sphere class Virtual print function but it calls Geometry class print function which is the Parent of Sphere class.

#include "pch.h"
#include <iostream>
#include<fstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "Container.h"
#include "Geometry.h"
#include "Sphere.h"

int main()
{
    const char* fileName = "saved.txt";
    Geometry* gg = new Sphere;
    Container *c = new Container("My Container", gg); // I have created a sphere object
    // save data
    {
        // Create an output archive
        std::ofstream ofs(fileName);
        boost::archive::text_oarchive ar(ofs);
        ar & c ;            
    }
    Container* c_Restored;  
    //load data
    {
        // create an input stream
        std::ifstream ifs(fileName);
        boost::archive::text_iarchive ar(ifs);
        ar & c_Restored;
    }

    Sphere* g1 = (Sphere*)c_Restored->getGeomtry();
    c_Restored->PrintContainer();
    g1->PrintGeom();  // This should call the Sphere PrintGeom function ???
    do
    {
        std::cout << '\n' << "Press a key to continue...";
    } while (std::cin.get() != '\n');
}

This is container class.

#pragma once

#include <boost/serialization/base_object.hpp>
#include <boost/serialization/split_member.hpp>
#include "Geometry.h"
class Container
{
private:
    std::string stdstrCont;
    Geometry* geom;

public:
    Container() : stdstrCont() { geom = new Geometry; }

    
    Container( std::string str , Geometry* geometry) : stdstrCont(str )
{ 
    Sphere* sph = new Sphere;
    geom = new Sphere(*sph);
}


    ~Container()
    {
        if (geom != nullptr)
            delete geom;
    }

    Geometry* getGeomtry()
    {
        return geom;
    }

    void PrintContainer()
    {
        std::cout << stdstrCont;
    }

private:

    friend class boost::serialization::access;

    void serialize(Archive& ar, const unsigned version) {
    Sphere* sss = (Sphere*)geom;
    ar & stdstrCont & sss;
}
    
};

This is Geometry Class

#pragma once

#include <string>

class Geometry
{
private:
    std::string stdstringGeom;

public:
     virtual void  PrintGeom()
    {
        std::cout << "geometry virtual function";
    }

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


    template <typename Archive>
    void serialize(Archive& ar, const unsigned version) {
        ar & stdstringGeom;
    }
};

This is sphere class.

include "Geometry.h"

class Sphere : public Geometry
{
private:
    std::string stdstrSphere;


public:
    Sphere() : stdstrSphere( "DefaultSphere"){}
    Sphere( std::string str) : stdstrSphere(str) {}
    void PrintGeom()
    {
        std::cout << "Sphere Virtual Function" << std::endl;
    }

private:
    typedef Geometry _Super;
    friend class boost::serialization::access;


    template <typename Archive>
    void serialize(Archive& ar, const unsigned version) {
        ar & boost::serialization::base_object<_Super>(*this);
        ar & stdstrSphere;
    }

};

I feel the issue is here in container serialize function.

 template <typename Archive>
        void serialize(Archive& ar, const unsigned version) {
            
            ar & stdstrCont & geom;
        }

Though i am serializing a Sphere object but while deserializing it constructs a Geomtry object.

Answer 1

@G.M. is right in his the comments.

Here you slice your Sphere object into a Geometry object:

    Container* c = new Container("My Container", new Sphere());
...

    Container(std::string str, Geometry* geometry) : stdstrCont(str)
    {
        geom = new Geometry;
        *geom = *geometry;
    }

And once the slicing is done it is a Geometry object, and then the correct serialization is to serialize (and restore) it as a base Geometry object. So I am fairly sure that the boost serialization works as it should, but that you simply are feeding it garbage (or at least not what you intend to feed it).

In fact this very reduced version of your main also calls the printGeom in the Geometry class (as it should, after slicing):

int main()
{
    Container* c = new Container("My Container", new Sphere);
    Sphere* g1 = (Sphere*)c->getGeomtry();
    g1->PrintGeom();
}

So my recommendation would be to fix your Container constructor (which, depending on what you want, may involve making a copy-constructor in Sphere). If this causes new problems, then write a new question here for that part specifically.