Comment sérialiser des pointeurs partagés/faibles?

Question

J'ai un réseau complexe d'objets connectés avec QSharedPointers et QWeakPointers. Existe-t-il un moyen simple de les sauvegarder/charger avec Boost.Serialization? Jusqu'à présent, j'ai ceci:

namespace boost { 
    namespace serialization { 
     template<class Archive, class T> 
     void save(Archive& ar, QSharedPointer<T> const& ptr, unsigned version) { 
      T* sharedPointer = ptr.data(); 
      ar & BOOST_SERIALIZATION_NVP(sharedPointer); 
     } 

     template<class Archive, class T> 
     void load(Archive& ar, QSharedPointer<T>& ptr, unsigned version) { 
      T* sharedPointer = 0; 
      ar & BOOST_SERIALIZATION_NVP(sharedPointer); 
      ptr = QSharedPointer<T>(sharedPointer); 
     } 

     template<class Archive, class T> 
     void save(Archive& ar, QWeakPointer<T> const& ptr, unsigned version) { 
      T* weakPointer = ptr.toStrongRef().data(); 
      ar & BOOST_SERIALIZATION_NVP(weakPointer); 
     } 

     template<class Archive, class T> 
     void load(Archive& ar, QWeakPointer<T>& ptr, unsigned version) { 
      T* weakPointer = 0; 
      ar & BOOST_SERIALIZATION_NVP(weakPointer); 
      ptr = QSharedPointer<T>(weakPointer); 
     } 
    } 
} 

Ce ne fonctionne pas parce que les pointeurs partagés sont toujours construits à partir des pointeurs premières afin qu'ils pensent tous le nombre de références est 1. Il a également libère immédiatement des pointeurs faibles. Avec un peu d'effort, je peux convertir les classes pour utiliser boost::shared_ptr et boost::weak_ptr. Cela fera-t-il du bien?

Answer 1

La question est de savoir ce que vous voulez vraiment réaliser en sérialisant les pointeurs. Quelle est votre sortie attendue? Notez que les pointeurs pointent vers un endroit en mémoire - plusieurs peuvent pointer vers le même endroit en mémoire.

La sérialisation de l'adresse ne fonctionnera pas. Vous ne pouvez pas simplement écrire l'adresse exacte de la mémoire, car il n'y a aucun moyen de garantir que les objets de la prochaine exécution pourront prendre le même espace (un autre programme peut avoir déjà réservé cet emplacement).

sérialisation l'objet pointé dans chaque endroit où nous avons un pointeur wont travail:

1. Ce serait beaucoup plus de données que nous avions besoin de sérialisation
2. Si nous avions des pointeurs faibles création une dépendance circulaire nous ne serions pas en mesure d'arrêter et de récupérer cette connexion plus tard.
3. Il n'y a aucun moyen de fusionner les mêmes objets dans un quand désérialisation

Maintenant que vous pensez, vous pouvez essayer de la réponse officielle de boost::serialization:

• boost::serialization on shared_ptr
• boost::serialization on shared_ptr 2