Sérialiser une classe qui contient une chaîne std :: string

Je ne suis pas un c++ expert, mais j'ai sérialisé choses une couple de fois dans le passé. Malheureusement, cette fois, je suis en train de sérialiser une classe qui contient une std::string, je crois comprendre que c'est un peu comme de la sérialisation d'un pointeur.

Je peux écrire la classe dans un fichier et de le lire à nouveau. Tous les int les champs sont bien, mais le std::string champ donne une adresse en dehors des limites d'erreur", sans doute parce que les points de données qui n'est plus là.

Est-il un standard solution pour cela? Je ne veux pas revenir à des tableaux de char, mais au moins je sais qu'ils travaillent dans cette situation. Je peux fournir le code si nécessaire, mais j'espère que j'ai expliqué mon problème.

Je suis la sérialisation par la coulée de la classe à un char* et l'écrire dans un fichier avec fstream. La lecture est évidemment tout l'inverse.

source d'informationauteur iwasinnamuknow

  1. 10

    Je suis la sérialisation par la coulée de la classe à un char* et de les écrire sur un
    fichier avec fstream. La lecture est évidemment tout l'inverse.

    Malheureusement, cela ne fonctionne que tant qu'il n'y a pas des pointeurs. Vous pourriez vouloir donner à vos classes void MyClass::serialize(std::ostream) et void MyClass::deserialize(std::ifstream)et appelez-les. Dans ce cas, vous voulez 

    std::ostream& MyClass::serialize(std::ostream &out) const {
    out << height;
    out << ',' //number seperator
    out << width;
    out << ',' //number seperator
    out << name.size(); //serialize size of string
    out << ',' //number seperator
    out << name; //serialize characters of string
    return out;
}
std::istream& MyClass::deserialize(std::istream &in) {
    if (in) {
        int len=0;
        char comma;
        in >> height;
        in >> comma; //read in the seperator
        in >> width;
        in >> comma; //read in the seperator
        in >> len;  //deserialize size of string
        in >> comma; //read in the seperator
        if (in && len) {
            std::vector<char> tmp(len);
            in.read(tmp.data() , len); //deserialize characters of string
            name.assign(tmp.data(), len);
        }
    }
    return in;
}

    Vous pouvez aussi surcharger le flux des opérateurs pour une utilisation plus facile.

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

    Simplement d'écrire le contenu binaire d'un objet dans un fichier n'est pas seulement portables mais, comme vous l'avez reconnu, ne fonctionne pas pour le pointeur de données. En gros, vous avez deux options: soit vous écrivez une véritable bibliothèque de sérialisation, qui gère std::les chaînes de caractères correctement en utilisant, par exemple c_str() à la sortie de la chaîne réelle du fichier, ou vous utilisez l'excellent stimuler la sérialisation de la bibliothèque. Si possible, je vous recommande le dernier, vous pouvez sérialiser avec un simple code comme ceci:

    #include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/string.hpp>

class A {
    private:
        std::string s;
    public:
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & s;
        }
};

    Ici, la fonction serialize travaux pour la sérialisation et la désérialisation des données, en fonction de comment vous l'appelez. Voir la documentation pour plus d'informations.

  3. 2

    La meilleure méthode de sérialisation pour les chaînes ou d'autres gouttes avec la variable de la taille est de sérialiser d'abord la taille que vous sérialiser des entiers, alors il suffit de copier le contenu dans le flux de sortie.

    Lors de la lecture de lire d'abord la taille, puis allouer de la chaîne, puis remplir par lire le nombre d'octets dans le flux.

    Une alternative est d'utiliser un séparateur et d'évasion, mais nécessite plus de code et est plus lente à la fois sur la sérialisation et la désérialisation (cependant, le résultat peut être gardé lisible par l'homme).

  4. 1

    Vous aurez à utiliser un plus compliqué méthode de sérialisation de la coulée d'une classe à un char* et écrire dans un fichier si votre classe contient toutes les données exogènes (string n'). Et vous avez raison au sujet de pourquoi vous obtenez une erreur de segmentation.

    Je voudrais faire une fonction membre qui serait prendre un fstream et lire les données à partir d'une fonction inverse qui serait de prendre un fstream et écrire du contenu pour qu'il soit restauré plus tard, comme ceci:

    class MyClass {
pubic:
    MyClass() : str() { }

    void serialize(ostream& out) {
        out << str;
    }

    void restore(istream& in) {
        in >> str;
    }

    string& data() const { return str; }

private:
    string str;
};

MyClass c;
c.serialize(output);

//later
c.restore(input);

    Vous pouvez également définir operator<< et operator>> de travailler avec istream et ostream pour sérialiser et de restauration de votre classe ainsi si vous voulez que le sucre syntaxique.

  5. 0

    Pourquoi ne pas simplement quelque chose le long des lignes de:

    std::ofstream ofs;
...

ofs << my_str;

    et puis:

    std::ifstream ifs;
...

ifs >> my_str;
  6. 0
    /*!
 * reads binary data into the string.
 * @status : OK.
*/

class UReadBinaryString
{
    static std::string read(std::istream &is, uint32_t size)
    {
        std::string returnStr;
        if(size > 0)
        {
            CWrapPtr<char> buff(new char[size]);       //custom smart pointer
            is.read(reinterpret_cast<char*>(buff.m_obj), size);
            returnStr.assign(buff.m_obj, size);
        }

        return returnStr;
    }
};

class objHeader
{
public:
    std::string m_ID;

    //serialize
    std::ostream &operator << (std::ostream &os)
    {
        uint32_t size = (m_ID.length());
        os.write(reinterpret_cast<char*>(&size), sizeof(uint32_t));
        os.write(m_ID.c_str(), size);

        return os;
    }
    //de-serialize
    std::istream &operator >> (std::istream &is)
    {
        uint32_t size;
        is.read(reinterpret_cast<char*>(&size), sizeof(uint32_t));
        m_ID = UReadBinaryString::read(is, size);

        return is;
     }
};
  7. -1

    Je n'ai pas codé en C++ dans un temps long, mais vous pourriez peut-être sérialiser un tableau de char.

    Ensuite, lorsque vous ouvrez votre fichier, votre string voudrais juste pointer vers le tableau.

    Juste une idée.