Исключение, выполняемое при выполнении кода [duplicate]

Самый простой способ сериализации для строк или других блоков с переменным размером - это сериализовать сначала размер при сериализации целых чисел, а затем просто скопировать содержимое в выходной поток.

При чтении сначала читайте размер , затем выделите строку и затем заполните ее, прочитав правильное количество байтов из потока.

Альтернативой является использование разделителя и экранирования, но для этого требуется больше кода и медленнее как при сериализации, так и при десериализации ( однако результат может быть сохранен для чтения человеком).

Просто запись двоичного содержимого объекта в файл не только не переносима, но, как вы признали, не работает для данных указателя. В основном у вас есть два варианта: либо вы пишете настоящую библиотеку сериализации, которая правильно обрабатывает std :: strings, например. используя c_str () , чтобы вывести фактическую строку в файл, или вы используете отличную библиотеку boostization . Если это вообще возможно, я бы рекомендовал последнее, вы можете сериализовать с помощью простого кода следующим образом:

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

Здесь функция serialize работает для сериализации и десериализации данных, в зависимости от как вы это называете. Дополнительную информацию см. В документации.

Я долго не кодировал C ++, но, возможно, вы могли бы сериализовать массив из char.

Затем, когда вы открываете файл, ваш string будет просто указывать на массив.

Просто идея.

/*!
 * 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;
     }
};

Почему не просто что-то вроде:

std::ofstream ofs;
...

ofs << my_str;

, а затем:

std::ifstream ifs;
...

ifs >> my_str; 

Вам придется использовать более сложный метод сериализации, чем приведение класса к char* и запись его в файл, если ваш класс содержит любые экзогенные данные (string). И вы правы в том, почему вы получаете ошибку сегментации.

Я бы сделал функцию-член, которая будет принимать fstream и читать данные из нее, а также обратную функцию, которая возьмите fstream и напишите его содержимое для его восстановления позже, например:

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

Вы также можете определить operator<< и operator>> для работы с istream и ostream для сериализации и восстановления вашего класса, если вы хотите использовать этот синтаксический сахар.