Boost Serialización del objeto que contiene el Mapa (con valores de objeto) y Multimap (con valores std :: string): ¿qué se necesita?

Question

Vea a continuación una principal() y dos clases muy simples. Luego, por cada serialización de Boost (y lo que se muestra), mis preguntas son:

1) ¿La clase B necesita los operadores de inserción de flujo normal sobrecargado '< <' y '>>' por definir? Actualmente en mi código real no tiene estos.

2) ¿La clase A en los métodos store() y load() necesita iterar explícitamente a través del mapa y los contenedores multimap, almacenando/cargando sus pares key: value explícitamente? p. algo así como:

void A::store(const char* filename){ 

std::ofstream ofs(filename); 
boost::archive::text_oarchive oa(ofs); 

std::map< std::string, B >::iterator it; 

BMap.size(); 
oa << BMap.size(); 
for(it = BMap.begin(); it != BMap.end(); it++){ 
    oa << it->first; 
    oa << it->second; 
} 

//similar for strMultimap 
} 

Supongo que no necesito hacer esto, pero no estoy seguro.

3) Suponiendo que la clase B tiene solo los dos miembros de datos mostrados, ¿necesita un contructor predeterminado incluido explícitamente? (a diferencia del constructor predeterminado implícito)

4) ¿Necesita B un sobreventa para el operador de comparación '>'? Supongo que no, ya que esta es una clase muy simple.

¡Finalmente, apreciamos cualquier otro comentario por cualquier cosa que no he podido cubrir!

Código de ejemplo para mis preguntas anteriores:

//includes ommitted 

int main() { 

    std::string file("test.dat"); 

    A * pA = new A; 

    pA->store(file.c_str()); 
    pA->fillMaps(); 
    //release data 
    pA->load(file.c_str()); 

    return 0; 
} 

//includes ommitted 

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

public: 

    std::map< std::string, B > BMap; 
    std::multimap< std::string, std::string > strMultimap; 

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

    void store(const char* filename){ 

    std::ofstream ofs(filename); 
    boost::archive::text_oarchive oa(ofs); 
    oa << this; 
    } 

    void load(const char* filename){ 

    std::ifstream ifs(filename); 
    boost::archive::text_iarchive ia(ifs); 
    ia >> this; 

    } 

    void fillMaps(){ 

//code to allocate B objects and put them in BMap and fill strMultimap with whatever number of key:value pairs 

} 

class B 
{ 
friend class boost::serialization::access; 

public: 

    std::string str; 
    unsigned int num; 

    B::B(void) 
    : str("a string") 
    , num(7) 
    { 
    } 

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

Answer 1

1) No es necesario operadores de flujo para la clase B, pero necesita un método serialize(). Tenía que envuelva la serialización con la macro BOOST_SERIALIZATION_NVP (nombre del valor par):

ar & BOOST_SERIALIZATION_NVP(someNamedValue); // use this macro for everything you want to name 

Puede haber una manera de evitar el nombramiento de su mapa, pero no sé cómo se hace.

2) No, la clase A no necesita el código de serialización específico del mapa. Solo asegúrate de incluir <boost/serialization/map.hpp>.

3) El constructor predeterminado implícito debería estar bien. Solo necesitas un constructor predeterminado explícito si a) ya has proporcionado un constructor no predeterminado ob) quieres cambiar el comportamiento del constructor predeterminado. se necesita

4) Ningún operador < :)

He aquí algunos ejemplos de código, que compila, pero no he corrido:

#include <boost/serialization/map.hpp> 

struct A 
{ 
    struct B 
    { 
     template<class Archive> 
     void serialize(Archive &ar, const unsigned int version) 
     { 
     } 
    }; 
    typedef std::map<int, SomeClass> MyMap; 
    MyMap myMap; 

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