Có thể tuần tự hóa và giải tuần tự hóa một lớp trong C ++ không?

Có thể tuần tự hóa và giải tuần tự hóa một lớp trong C ++ không?

Tôi đã sử dụng Java được 3 năm rồi và việc tuần tự hóa / giải tuần tự hóa khá tầm thường trong ngôn ngữ đó. C ++ có các tính năng tương tự không? Có thư viện riêng xử lý tuần tự hóa?

Một ví dụ sẽ hữu ích.

Các Boost::serializationthư viện xử lý này khá thanh lịch. Tôi đã sử dụng nó trong một số dự án. Có một chương trình ví dụ, cho thấy cách sử dụng nó ở đây .

Cách duy nhất để làm điều đó là sử dụng các luồng. Về cơ bản, tất cả các Boost::serializationthư viện đều làm như vậy, nó mở rộng phương thức truyền phát bằng cách thiết lập một khung để viết các đối tượng thành định dạng giống như văn bản và đọc chúng từ cùng định dạng.

Đối với các loại tích hợp hoặc các loại của riêng bạn operator<<và operator>>được xác định đúng, điều đó khá đơn giản; xem C ++ FAQ để biết thêm thông tin.

Tôi nhận ra đây là một bài viết cũ nhưng nó là một trong những bài đầu tiên xuất hiện khi tìm kiếm c++ serialization.

Tôi khuyến khích bất cứ ai có quyền truy cập vào C ++ 11 hãy xem ngũ cốc , thư viện chỉ dành cho tiêu đề C ++ 11 để tuần tự hóa hỗ trợ nhị phân, JSON và XML. ngũ cốc được thiết kế để dễ dàng mở rộng và sử dụng và có cú pháp tương tự như Boost.

Boost là một gợi ý tốt. Nhưng nếu bạn muốn tự lăn, nó không quá khó.

Về cơ bản, bạn chỉ cần một cách để xây dựng một biểu đồ các đối tượng và sau đó xuất chúng sang một số định dạng lưu trữ có cấu trúc (JSON, XML, YAML, bất cứ điều gì). Xây dựng biểu đồ đơn giản như sử dụng thuật toán đối tượng đệ quy đánh dấu và sau đó xuất ra tất cả các đối tượng được đánh dấu.

Tôi đã viết một bài báo mô tả một hệ thống tuần tự thô sơ (nhưng vẫn mạnh mẽ). Bạn có thể thấy thú vị: Sử dụng SQLite làm Định dạng tệp trên đĩa, Phần 2 .

Theo như các thư viện "tích hợp", <<và >>đã được dành riêng để tuần tự hóa.

Bạn nên ghi đè <<để xuất đối tượng của mình sang một số bối cảnh tuần tự hóa (thường là một iostream) và >>để đọc lại dữ liệu từ bối cảnh đó. Mỗi đối tượng chịu trách nhiệm xuất ra các đối tượng con tổng hợp của nó.

Phương pháp này hoạt động tốt miễn là đồ thị đối tượng của bạn không chứa chu kỳ.

Nếu vậy, bạn sẽ phải sử dụng một thư viện để đối phó với các chu kỳ đó.

Tôi khuyên dùng bộ đệm giao thức Google . Tôi đã có cơ hội lái thử thư viện trong một dự án mới và nó rất dễ sử dụng. Thư viện được tối ưu hóa rất nhiều cho hiệu suất.

Protobuf khác với các giải pháp tuần tự hóa khác được đề cập ở đây theo nghĩa là nó không tuần tự hóa các đối tượng của bạn, mà tạo ra mã cho các đối tượng được tuần tự hóa theo đặc điểm kỹ thuật của bạn.

Boost :: serialization là một lựa chọn tuyệt vời, nhưng tôi đã gặp một dự án mới: Ngũ cốc mà tôi thấy thanh lịch hơn nhiều! Tôi rất đề nghị điều tra nó.

Bạn có thể kiểm tra giao thức amef , một ví dụ về mã hóa C ++ trong amef sẽ như thế nào,

    //Create a new AMEF object
    AMEFObject *object = new AMEFObject();

    //Add a child string object
    object->addPacket("This is the Automated Message Exchange Format Object property!!","adasd");   

    //Add a child integer object
    object->addPacket(21213);

    //Add a child boolean object
    object->addPacket(true);

    AMEFObject *object2 = new AMEFObject();
    string j = "This is the property of a nested Automated Message Exchange Format Object";
    object2->addPacket(j);
    object2->addPacket(134123);
    object2->addPacket(false);

    //Add a child character object
    object2->addPacket('d');

    //Add a child AMEF Object
    object->addPacket(object2);

    //Encode the AMEF obejct
    string str = new AMEFEncoder()->encode(object,false);

Giải mã trong java sẽ như thế nào,

    string arr = amef encoded byte array value;
    AMEFDecoder decoder = new AMEFDecoder()
    AMEFObject object1 = AMEFDecoder.decode(arr,true);

Việc triển khai Giao thức có codec cho cả C ++ và Java, phần thú vị là nó có thể giữ lại biểu diễn lớp đối tượng dưới dạng các cặp giá trị tên, tôi yêu cầu một giao thức tương tự trong dự án cuối cùng của tôi, khi tôi tình cờ gặp giao thức này, tôi thực sự đã tình cờ sửa đổi thư viện cơ sở theo yêu cầu của tôi. Hy vọng điều này sẽ giúp bạn.

Tôi khuyên bạn nên sử dụng tuần tự tăng cường như được mô tả bởi các áp phích khác. Dưới đây là một hướng dẫn chi tiết tốt về cách sử dụng nó bổ sung cho các hướng dẫn tăng cường độc đáo: http://www.vitydert.com/blog/2011/07/09/a-prreal-guide-to-c-serialization/

Sweet Persist là một trong những khác.

Có thể tuần tự hóa đến và từ các luồng ở định dạng XML, JSON, Lua và nhị phân.

Tôi đề nghị xem xét các nhà máy trừu tượng thường được sử dụng làm cơ sở cho việc tuần tự hóa

Tôi đã trả lời trong một câu hỏi SO khác về các nhà máy C ++. Xin vui lòng xem ở đó nếu một nhà máy linh hoạt được quan tâm. Tôi cố gắng mô tả một cách cũ từ ET ++ để sử dụng các macro đã hoạt động rất tốt cho tôi.

ET ++ là một dự án chuyển MacApp cũ sang C ++ và X11. Trong nỗ lực của nó, Eric Gamma v.v ... bắt đầu nghĩ về các mẫu thiết kế . ET ++ chứa các cách tự động để tuần tự hóa và hướng nội khi chạy.

Nếu bạn muốn hiệu suất đơn giản và tốt nhất và không quan tâm đến khả năng tương thích dữ liệu lạc hậu, hãy thử HPS , nó nhẹ, nhanh hơn nhiều so với Boost, v.v. và dễ sử dụng hơn nhiều so với Protobuf, v.v.

Thí dụ:

std::vector<int> data({22, 333, -4444});
std::string serialized = hps::serialize_to_string(data);
auto parsed = hps::parse_from_string<std::vector<int>>(serialized);

Đây là một thư viện serializer đơn giản tôi gõ lên. Đó chỉ là tiêu đề, c11 và có các ví dụ để tuần tự hóa các loại cơ bản. Đây là một bản đồ cho lớp.

https://github.com/goblinhack/simple-c-plus-plus-serializer

#include "c_plus_plus_serializer.h"

class Custom {
public:
    int a;
    std::string b;
    std::vector c;

    friend std::ostream& operator<<(std::ostream &out, 
                                    Bits my)
    {
        out << bits(my.t.a) << bits(my.t.b) << bits(my.t.c);
        return (out);
    }

    friend std::istream& operator>>(std::istream &in, 
                                    Bits my)
    {
        in >> bits(my.t.a) >> bits(my.t.b) >> bits(my.t.c);
        return (in);
    }

    friend std::ostream& operator<<(std::ostream &out, 
                                    class Custom &my)
    {
        out << "a:" << my.a << " b:" << my.b;

        out << " c:[" << my.c.size() << " elems]:";
        for (auto v : my.c) {
            out << v << " ";
        }
        out << std::endl;

        return (out);
    }
};

static void save_map_key_string_value_custom (const std::string filename)
{
    std::cout << "save to " << filename << std::endl;
    std::ofstream out(filename, std::ios::binary );

    std::map< std::string, class Custom > m;

    auto c1 = Custom();
    c1.a = 1;
    c1.b = "hello";
    std::initializer_list L1 = {"vec-elem1", "vec-elem2"};
    std::vector l1(L1);
    c1.c = l1;

    auto c2 = Custom();
    c2.a = 2;
    c2.b = "there";
    std::initializer_list L2 = {"vec-elem3", "vec-elem4"};
    std::vector l2(L2);
    c2.c = l2;

    m.insert(std::make_pair(std::string("key1"), c1));
    m.insert(std::make_pair(std::string("key2"), c2));

    out << bits(m);
}

static void load_map_key_string_value_custom (const std::string filename)
{
    std::cout << "read from " << filename << std::endl;
    std::ifstream in(filename);

    std::map< std::string, class Custom > m;

    in >> bits(m);
    std::cout << std::endl;

    std::cout << "m = " << m.size() << " list-elems { " << std::endl;
    for (auto i : m) {
        std::cout << "    [" << i.first << "] = " << i.second;
    }
    std::cout << "}" << std::endl;
}

void map_custom_class_example (void)
{
    std::cout << "map key string, value class" << std::endl;
    std::cout << "============================" << std::endl;
    save_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
    load_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
    std::cout << std::endl;
}

Đầu ra:

map key string, value class
============================
save to map_of_custom_class.bin
read from map_of_custom_class.bin

m = 2 list-elems {
    [key1] = a:1 b:hello c:[2 elems]:vec-elem1 vec-elem2
    [key2] = a:2 b:there c:[2 elems]:vec-elem3 vec-elem4
}

Tôi đang sử dụng mẫu sau để thực hiện tuần tự hóa:

template <class T, class Mode = void> struct Serializer
{
    template <class OutputCharIterator>
    static void serializeImpl(const T &object, OutputCharIterator &&it)
    {
        object.template serializeThis<Mode>(it);
    }

    template <class InputCharIterator>
    static T deserializeImpl(InputCharIterator &&it, InputCharIterator &&end)
    {
        return T::template deserializeFrom<Mode>(it, end);
    }
};

template <class Mode = void, class T, class OutputCharIterator>
void serialize(const T &object, OutputCharIterator &&it)
{
    Serializer<T, Mode>::serializeImpl(object, it);
}

template <class T, class Mode = void, class InputCharIterator>
T deserialize(InputCharIterator &&it, InputCharIterator &&end)
{
    return Serializer<T, Mode>::deserializeImpl(it, end);
}

template <class Mode = void, class T, class InputCharIterator>
void deserialize(T &result, InputCharIterator &&it, InputCharIterator &&end)
{
    result = Serializer<T, Mode>::deserializeImpl(it, end);
}

Đây Tlà loại bạn muốn tuần tự hóa Modelà một loại giả để phân biệt giữa các loại tuần tự khác nhau, ví dụ. cùng một số nguyên có thể được tuần tự hóa như endian nhỏ, endian lớn, varint, v.v.

Theo mặc định, các Serializerđại biểu nhiệm vụ cho đối tượng được tuần tự hóa. Đối với các loại được xây dựng, bạn nên tạo một chuyên môn mẫu của Serializer.

Mẫu chức năng thuận tiện cũng được cung cấp.

Ví dụ: tuần tự hóa endian nhỏ của số nguyên không dấu:

struct LittleEndianMode
{
};

template <class T>
struct Serializer<
    T, std::enable_if_t<std::is_unsigned<T>::value, LittleEndianMode>>
{
    template <class InputCharIterator>
    static T deserializeImpl(InputCharIterator &&it, InputCharIterator &&end)
    {
        T res = 0;

        for (size_t i = 0; i < sizeof(T); i++)
        {
            if (it == end) break;
            res |= static_cast<T>(*it) << (CHAR_BIT * i);
            it++;
        }

        return res;
    }

    template <class OutputCharIterator>
    static void serializeImpl(T number, OutputCharIterator &&it)
    {
        for (size_t i = 0; i < sizeof(T); i++)
        {
            *it = (number >> (CHAR_BIT * i)) & 0xFF;
            it++;
        }
    }
};

Sau đó để tuần tự hóa:

std::vector<char> serialized;
uint32_t val = 42;
serialize<LittleEndianMode>(val, std::back_inserter(serialized));

Để giải trừ:

uint32_t val;
deserialize(val, serialized.begin(), serialized.end());

Do logic iterator trừu tượng, nó sẽ hoạt động với bất kỳ iterator nào (ví dụ: iterator stream), con trỏ, v.v.