boost serialization. загрузка данных из архива в std::list

#include<boost/serialization/list.hpp>
boost::archive::text_iarchive oarch(ofs);
 
//регистрируем тип
oarch.register_type<Derived>();
std::list<Derived*> list1;
...//заполняем лист
 
//записываем в архив
oarch << list1;

boost::archive::text_iarchive iarch(ifs);
std::list<Derived*> temp;
iarch >> temp;

boost::archive::text_iarchive oarch(ofs);
std::list<Derived*> list1;
...//заполняем лист
 
//записываем последний элемент из листа
oarch << list1.back();

boost::archive::text_iarchive iarch(ifs);
Derived* var;
iarch >> var;

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/list.hpp>
 
#include <list>
#include <sstream>
#include <iostream>
 
class Base
{
   friend class boost::serialization::access;
   template<typename Archive>
   void serialize(Archive&, const unsigned int)
   {
      
   }
public:
   virtual ~Base() = 0;
   virtual int get() const = 0;
};
 
Base::~Base() {}
 
class Derived : public Base
{
   friend class boost::serialization::access;
   template<typename Archive>
   void serialize(Archive& ar, const unsigned int)
   {
      ar & boost::serialization::base_object<Base>(*this);
   }
public:
   Derived(int val) : value(val)
   {
   }
   int get() const { return value; }
private:
   int value;
};
 
namespace boost { namespace serialization {
 
template<typename Archive>
void save_construct_data(Archive& ar, const Derived* d, const unsigned int)
{
   int value = d->get();
   ar << value;
}
 
template<typename Archive>
void load_construct_data(Archive& ar, Derived* d, const unsigned int)
{
   int value = 0;
   ar >> value;
   ::new(d) Derived(value);
}
 
}
 
}
 
int main()
{
   std::list<Base*> ders = 
   {
      new Derived(5),
      new Derived(10)
   };
   std::stringstream ss;
   boost::archive::text_oarchive oarch(ss);
   oarch.register_type<Derived>();
   oarch << ders;
   std::cout << ss.str() << std::endl;
   boost::archive::text_iarchive iarch(ss);
   iarch.register_type<Derived>();
   std::list<Base*> outs;
   iarch >> outs;
   for (const auto& p : outs)
   {
      std::cout << p->get() << std::endl;
   }
}

std::list<someClase*>

serialize

SomeClass