Puis-je sérialiser la carte de STL dans MFC en utilisant CArchive?

Question

J'ai besoin d'écrire le contenu d'une carte (la clé est ID de int, la valeur est de struct auto-défini) dans un fichier, et le charger à partir du fichier plus tard. Puis-je le faire en MFC avec CArchive?

Merci!

Answer 1

Je ne sais pas grand-chose à propos de MFC, mais votre problème est plutôt trivialement résolu en utilisant Boost.Serialization

struct MapData { 
    int m_int; 
    std::string m_str; 

    private: 
    friend class boost::serialization::access; 

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

std::map< int, MapData > theData; 

template<class Archive> 
void serialize(Archive & ar, std::map< int, MapData > & data, const unsigned int version) 
{ 
    ar & data; 
} 

Et puis plus tard étiez vous voulez faire le vrai archivage:

std::ofstream ofs("filename"); 
boost::archive::binary_oarchive oa(ofs); 
oa << theData; 

Ca y est .

(disclaimer: le code simplement tapé dans cette case, pas testé du tout, de faute de frappe étaient destinés;)

Answer 2

Dans MFC, je crois qu'il est plus facile d'abord sérialiser la taille de la carte, puis simplement itérer tous les éléments.

Vous n'avez pas spécifié si vous utilisez std::map ou MFC CMap, mais une version basée sur std::map pourrait ressembler à ceci:

void MyClass::Serialize(CArchive& archive) 
{ 
    CObject::Serialize(archive); 
    if (archive.IsStoring()) { 
    archive << m_map.size(); // save element count 
    std::map<int, MapData>::const_iterator iter = m_map.begin(), 
              iterEnd = m_map.end(); 
    for (; iter != iterEnd; iter++) { 
     archive << iter->first << iter->second; 
    } 
    } 
    else { 
    m_map.clear(); 
    size_t mapSize = 0; 
    archive >> mapSize; // read element count 
    for (size_t i = 0; i < mapSize; ++i) { 
     int key; 
     MapData value; 
     archive >> key; 
     archive >> value; 
     m_map[key] = value; 
    } 
    } 
} 

Si une erreur se produit lors de la lecture de l'archive, l'une des opérations de diffusion en continu devrait lancer une exception, qui serait alors interceptée par le framework à un niveau supérieur.