Comment sérialiser correctement une classe contenant un std::string en C ?

Sérialisation d'une classe contenant un std::string : Comprendre le dilemme du pointeur

La sérialisation est une technique cruciale utilisée pour préserver l'état des objets pour le stockage ou le transfert. Cependant, la sérialisation de classes contenant std::strings présente un défi en raison de la nature du pointeur de std::strings.

Le problème survient lorsque l'on tente de sérialiser une classe contenant un std::string en la convertissant en char. * et l'écrire dans un fichier. Cette approche fonctionne pour les types de données simples mais échoue avec std::strings car elle ne prend pas en compte les dépendances du pointeur.

Une solution de contournement standard pour la sérialisation du pointeur

Pour surmonter Pour résoudre ce problème, une solution de contournement standard consiste à introduire des méthodes de sérialisation et de désérialisation dans la classe. Ces méthodes gèrent manuellement l'écriture et la lecture des données internes de l'objet, y compris les pointeurs.

Un exemple d'implémentation pourrait être le suivant :

// Serialization method
std::ostream& MyClass::serialize(std::ostream &out) const {
    // Serialize numeric values using the output stream
    out << height;
    out << ',' // Separator
    out << width;
    out << ',' // Separator
    
    // Serialize the std::string
    out << name.size(); // String length
    out << ',' // Separator
    out << name; // String characters
    
    return out;
}

// Deserialization method
std::istream&amp; MyClass::deserialize(std::istream &amp;in) {
    if (in) {
        // Deserialize numeric values using the input stream
        int len=0;
        char comma;
        in >> height;
        in >> comma; // Separator
        in >> width;
        in >> comma; // Separator
        
        // Deserialize the std::string
        in >> len; // String length
        in >> comma; // Separator
        if (in &amp;&amp; len) {
            std::vector<char> tmp(len);
            in.read(tmp.data() , len); // String characters
            name.assign(tmp.data(), len);
        }
    }
    return in;
}

La surcharge des opérateurs de flux peut simplifier l'utilisation de ces derniers. méthodes :

std::ostream &amp;operator<<(std::ostream&amp; out, const MyClass &amp;obj)
{obj.serialize(out); return out;}
std::istream &amp;operator>>(std::istream&amp; in, MyClass &amp;obj)
{obj.deserialize(in); return in;}

En utilisant ces techniques, std::strings peut être efficacement sérialisé et désérialisé dans le cadre d'une classe plus grande, préservant ainsi leur intégrité et dépendances de pointeur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!