boost serialize polymorphic class

问题

With the following example I attempting to learn a few new to me concepts.

abstraction
polymorphic classes
factory programming.
boost serialization

The nuances of how pointers behave are still something I am working to figure out.

Here is a small program that I have written to show you the issue I am struggling to understand. When I unserialize the polymorphic object below I only get an object created from the default constructor.
TodoFactory::retrieveATodo is not recreating the object from the serialized data. This is displayed by the output of "unserialzed command" in that function.

Here is the full program:

#include <string>
#include <bitset>
#include <boost/serialization/string.hpp>
#include <sstream>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>

//abstract class
class aTodo{
private:

   friend class boost::serialization::access;

protected:
   const char _initType;

public:
   aTodo():_initType(0x00){};

   aTodo(const char type):_initType(type){};

std::string  oarchive(){
   std::ostringstream archive_stream;
   {
   boost::archive::text_oarchive archive(archive_stream);
   archive << *this;
   }

   archive_stream.flush();
   std::string outbound_data=archive_stream.str();

   std::string  foutbound_data;
   foutbound_data=_initType;
   foutbound_data+=outbound_data;
   std::cout << "length: " << foutbound_data.length() << std::endl;
   return foutbound_data;
}


   virtual void Do()=0;
   virtual ~aTodo(){};

   template<class Archive>
   void serialize(Archive & ar, unsigned int version){
      ar & _initType;
   };
   char getInitType(){return _initType;};
};

// include headers that implement a archive in simple text format
class todoExec:public aTodo{
private:
  friend class boost::serialization::access;
   template<class Archive>
   void serialize(
            Archive& ar,
            unsigned int version
            )
    {
      std::cout << "serialize todoexec" << std::endl;
    //base
    boost::serialization::base_object<aTodo>(*this);
//derived
        ar & _command;
    }

  std::string _command;
protected:

public:
   static const char _TYPE=0x01;
   todoExec():aTodo(_TYPE){};
   todoExec(std::string command):aTodo(_TYPE){_command=command;};
   void Do(){std::cout << "foo" << std::endl;};
   virtual ~todoExec(){};

   std::string getCommand(){return _command;};


};

class todoFactory{
private:

protected:


public:
   std::unique_ptr<aTodo> retrieveAtodo(const std::string & total){
   std::cout << "here" << std::endl;
   char type=total.at(0);
   std::cout << "bitset: " << std::bitset<8>(type) << std::endl;
   std::string remainder=total.substr(1);
   if(type==0x01){
      std::cout << "remainder in retrieve: " << remainder << std::endl;
      std::unique_ptr<todoExec> tmp(new todoExec());
      std::stringstream archive_stream(remainder);
      std::cout << "stream remainder: " << archive_stream.str() << std::endl;
   {     
      boost::archive::text_iarchive archive(archive_stream);
      archive >> *tmp;
      }
      std::cout << "unserialized type: " << std::bitset<8>(tmp->getInitType()) << std::endl;
      std::cout << "unserialized command: " << tmp->getCommand() << std::endl;
      return std::move(tmp);
   }
   };

   std::unique_ptr<aTodo> createAtodo(char type,std::string command){

      if(type==0x01){
         std::unique_ptr<todoExec> tmp(new todoExec(command));
         return std::move(tmp);
      }
   };


};

int main(){
   char mtype=0x01;
   std::string dataToSend = "ls -al /home/ajonen";
   std::unique_ptr<todoFactory> tmpTodoFactory; //create factory
   std::unique_ptr<aTodo> anExecTodo=tmpTodoFactory->createAtodo(mtype,dataToSend); //create ExecTodo from factory
   if(auto* m = dynamic_cast<todoExec*>(anExecTodo.get()))
      std::cout << "command to serialize: " << m->getCommand() << std::endl;
   //archive
   std::string remainder = anExecTodo->oarchive();
   //now read in results that are sent back
   std::unique_ptr<aTodo> theResult;
   theResult=tmpTodoFactory->retrieveAtodo(remainder);
   std::cout << "resultant type: " << std::bitset<8>(theResult->getInitType()) <<std::endl;
   if(auto* d = dynamic_cast<todoExec*>(theResult.get()))
      std::cout << "resultant Command: " << d->getCommand() <<std::endl;


   return 0;
}

And here is the program output:

command to serialize: ls -al /home/ajonen
length: 36
here
bitset: 00000001
remainder in retrieve: 22 serialization::archive 12 0 0 1

stream remainder: 22 serialization::archive 12 0 0 1

serialize todoexec
unserialized type: 00000001
unserialized command: 
resultant type: 00000001
resultant Command:

I also found out that the serialize method is only being called for the base class aTodo. I am going to need to find a way to make that virtual, but it is a template function. That is problem number one.

回答1:

Your program has Undefined Behaviour because all of the factory functions have missing returns.

Next up, using a type code in a class hierarchy is a Design Smell.

Concrete hints:

serialize the same type as you deserialize
let Boost Serialization handle the polymorphism (otherwise, why do you use polymorphism, or why do you use Boost Serialization?). Boost handles it when you serialize (smart) pointers to base.
register your classes (BOOST_CLASS_EXPORT). You had included the header but didn't use it.
_{There doesn't seem to be a reason for the factory. Consider dropping it}

In general, remove cruft. it's hard to think when your code is too noisy. Here's my cleaned up version:

Live On Coliru

This also uses Boost for streaming to string without unnecessary copying.

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/unique_ptr.hpp>

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>

namespace Todo
{
    struct BaseTodo {
        using Ptr = std::unique_ptr<BaseTodo>;

        virtual ~BaseTodo() = default;
        virtual void Do() = 0;
        virtual unsigned getInitType() { return 0x00; };

      private:
        friend class boost::serialization::access;
        template <class Ar> void serialize(Ar &, unsigned) {}
    };

    class Exec : public BaseTodo {
      public:
        Exec(std::string const &command = "") : _command(command){};

        virtual unsigned getInitType() { return 0x01; };
        virtual void Do() { std::cout << "foo: " << getCommand() << std::endl; };

        std::string getCommand() const { return _command; };

      private:
        friend class boost::serialization::access;
        template <class Archive> void serialize(Archive &ar, unsigned) {
            boost::serialization::base_object<BaseTodo>(*this);
            ar &_command;
        }

        std::string _command;
    };
}

//BOOST_CLASS_EXPORT(BaseTodo)
BOOST_SERIALIZATION_ASSUME_ABSTRACT(Todo::BaseTodo)
BOOST_CLASS_EXPORT(Todo::Exec)

namespace Todo 
{
    class Factory {
        Factory() = default;
      public:
        using Ptr = BaseTodo::Ptr;
        using FactoryPtr = std::shared_ptr<Factory>;

        static FactoryPtr create() { return FactoryPtr(new Factory); }

        static std::string save(Ptr todo) {
            std::string out;
            {
                namespace io = boost::iostreams;
                io::stream<io::back_insert_device<std::string> > os(out);

                boost::archive::text_oarchive archive(os);
                archive << todo;
            }

            return out;
        }

        static Ptr load(std::string const &s) {
            Ptr p;
            {
                namespace io = boost::iostreams;
                io::stream<io::array_source> is(io::array_source{ s.data(), s.size() });
                boost::archive::text_iarchive archive(is);
                archive >> p;
            }
            return std::move(p);
        }

        Ptr createExec(std::string command) { return BaseTodo::Ptr(new Exec(command)); }
    };
}

int main() {
    auto factory = Todo::Factory::create();

    // ROUNDTRIP save,load
    auto todo = factory->load(
            factory->save(
                factory->createExec("ls -al /home/ajonen")
            )
        );

    std::cout << "Type: " << std::hex << std::showbase << todo->getInitType() << std::endl;
    todo->Do();
}

回答2:

Here's another take without virtuals, inheritance and dynamic allocations:

Live On Coliru

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/variant.hpp>

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>

namespace Todo
{
    struct None {
        void Do() const {};
        template <class Ar> void serialize(Ar&, unsigned) {}
    };

    class Exec {
      public:
        Exec(std::string const &command = "") : _command(command){};
        void Do() const { std::cout << "foo: " << getCommand() << std::endl; };

        std::string getCommand() const { return _command; };

      private:
        friend class boost::serialization::access;
        template <class Ar> void serialize(Ar &ar, unsigned) {
            ar &_command;
        }

        std::string _command;
    };

    using Todo = boost::variant<None, Exec>;

    struct Factory {
        static std::string save(Todo const& todo) {
            std::string out;
            {
                namespace io = boost::iostreams;
                io::stream<io::back_insert_device<std::string> > os(out);

                boost::archive::text_oarchive archive(os);
                archive << todo;
            }

            return out;
        }

        static Todo load(std::string const &s) {
            Todo todo;
            {
                namespace io = boost::iostreams;
                io::stream<io::array_source> is(io::array_source{ s.data(), s.size() });
                boost::archive::text_iarchive archive(is);
                archive >> todo;
            }
            return std::move(todo);
        }
    };
}

namespace visitors {
    namespace detail {
        template <typename F> struct internal_vis : boost::static_visitor<void> {
            internal_vis(F& f) : _f(f) {}
            template <typename... T>
                void operator()(T&&... a) const { return _f(std::forward<T>(a)...); }
            private:
                F& _f;
        };
    }

    template <typename F, typename V>
    void apply(F const& f, V const& v) { return boost::apply_visitor(detail::internal_vis<F const>(f), v); }

    template <typename F, typename V>
    void apply(F const& f, V& v) { return boost::apply_visitor(detail::internal_vis<F const>(f), v); }
}

namespace Todo { namespace Actions { template <typename T>
        void Do(T const& todo) {
            visitors::apply([](auto const& cmd) { cmd.Do(); }, todo);
        }
} }

int main() {
    using namespace Todo;
    Factory factory;

    // ROUNDTRIP save,load
    auto todo = factory.load(
            factory.save(
                Exec("ls -al /home/ajonen")
            )
        );

    std::cout << "Type: " << std::hex << std::showbase << todo.which() << std::endl;

    Actions::Do(todo);

}

Prints

Type: 0x1
foo: ls -al /home/ajonen

来源：https://stackoverflow.com/questions/30204189/boost-serialize-polymorphic-class

标签

c++

serialization

boost

polymorphism

abstract