Aumentare la serializzazione dell'oggetto contenente la mappa (con valori oggetto) e Multimap (con valori std :: string): cosa è necessario?

Question

Vedere sotto a main() e due classi molto semplici. Poi per Boost serializzazione (e ciò che è stato mostrato) le mie domande sono:

1) Se la classe B necessita '< <' e '>>' in via di definizione i normali operatori di inserimento flusso di overload? Attualmente nel mio codice reale non ce l'ha.

2) La classe A nei metodi store() e load() deve scorrere in modo esplicito attraverso la mappa e i contenitori multimap, memorizzando/caricando la chiave: coppie di valori esplicitamente? ad es. qualcosa di simile:

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 
} 

suppongo che non ho bisogno di fare questo, ma non ne sono certo.

3) Supponendo che la classe B abbia solo i due membri di dati mostrati, è necessario che un contructor di default sia incluso esplicitamente? (in contrasto con il costruttore implicito predefinito)

4) È necessario che B abbia un overide per l'operatore di confronto '>'? Presumo che non lo fa poiché questa è una classe molto semplice.

Infine, qualsiasi altro commento per qualcosa che non ho visto è apprezzato!

codice di esempio per le mie domande di cui sopra:

//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) Non è necessario operatori di flusso per la classe B, ma ha bisogno di un metodo serialize(). Ho dovuto avvolgere la serializzazione con la macro BOOST_SERIALIZATION_NVP (nome di valore coppia):

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

Ci potrebbe essere un modo per evitare di chiamare il vostro mappa, ma io non so come questo è fatto.

2) No, la classe A non richiede il codice di serializzazione specifico della mappa. Assicurati di includere <boost/serialization/map.hpp>.

3) Il costruttore implicito di default dovrebbe andare bene. Hai sempre solo bisogno di un esplicito costruttore predefinito se a) hai già fornito un costruttore non predefinito o b) vuoi cambiare il comportamento del costruttore predefinito. è necessario

4) Nessun operatore < :)

Ecco alcuni esempi di codice che ha compilato, ma non ho eseguito:

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