Boost Serializing obiektu zawierającego mapę (z wartościami obiektów) i Multimap (z wartościami std :: string): co jest potrzebne?

Question

Zobacz poniżej główną() i dwie bardzo proste klasy. Następnie na serializację Boost (i to, co jest pokazane), moje pytania są następujące:

1) Czy klasa B wymaga zdefiniowania operatorów o standardowej przeciążonej transmisji strumieniowej "< <" i ">>"? Obecnie w moim prawdziwym kodzie nie ma ich.

2) Czy klasa A w metodach store() i load() musi przejrzeć mapę i zbiorniki multimap wyraźnie, przechowując/ładując ich klucz: parę wartości explicitely? np. coś w rodzaju:

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 
} 

Zakładam, że nie muszę tego robić, ale nie jestem pewien.

3) Zakładając, że klasa B zawiera tylko dwa elementy danych, czy potrzebny jest domyślny kontroler dołączony explicitely? (w przeciwieństwie do ukrytego domyślnego konstruktora)

4) Czy B musi mieć nadmiar dla operatora porównania ">"? Zakładam, że tak nie jest, ponieważ jest to bardzo prosta klasa.

Wreszcie, wszelkie inne komentarze na wszystko, czego nie udało mi się pokonać, są doceniane!

Przykładowy kod dla moich powyższych pytań:

//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) Nie ma potrzeby operatorów strumieniowych dla klasy B, ale to nie potrzebujemy metody serialize(). Musiałem owinąć serializacji z BOOST_SERIALIZATION_NVP (wartość pary nazwa) Makro:

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

Nie może być sposobem na uniknięcie nazywając swoją mapę, ale nie wiem, jak to się robi.

2) Nie, klasa A nie wymaga kodu serializacji specyficznego dla mapy. Tylko pamiętaj, by dołączyć <boost/serialization/map.hpp>.

3) Domyślny domyślny konstruktor powinien być w porządku. Potrzebujesz tylko jawnego domyślnego konstruktora, jeśli a) podałeś już domyślny konstruktor lub b) chcesz zmienić zachowanie domyślnego konstruktora.

4) Nie operator < jest potrzebna :)

Oto niektóre przykładowy kod, który skompilowany, ale nie uruchomić:

#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); 
    } 
};