Serialization - Serialization of Classes

Boost , ,

Primitive Types

Class Types

Member Function

Free Function

Namespaces for Free Function Overrides

Class Members

Base Classes

const Members

Templates

Versioning

Splitting serialize into save/load

Member Functions

Free Functions

Pointers

Non-Default Constructors

Pointers to Objects of Derived Classes

Registration

Export

Instantiation

Selective Tracking

Runtime Casting

References

Arrays

Class Serialization Traits

Serialization Wrappers

Models - Serialization Implementations Included in the Library

• it is a primitive type.
  By primitive type we mean a C++ built-in type and ONLY a C++ built-in type. Arithmetic (including characters), bool, enum are primitive types. Below in serialization traits, we define a "primitive" implementation level in a different way for a different purpose. This can be a source of confusion.
• It is a class type and one of the following has been declared according to the prototypes detailed below:
  • a class member function serialize
  • a global function serialize
• it is a pointer to a Serializable type.
• it is a reference to a Serializable type.
• it is a native C++ Array of Serializable type.

Primitive Types

Class Types

Member Function

template<class Archive, class T>
inline void serialize(
    Archive & ar, 
    T & t, 
    const unsigned int file_version
){
    // invoke member function for class T
    t.serialize(ar, file_version);
}

template<class Archive>
void serialize(Archive &ar, const unsigned int version){
    ...
}

friend class boost::serialization::access;

Может быть не сразу очевидно, как этот шаблон служит как для сохранения данных в архив, так и для загрузки данных из архива. Ключ в том, что оператор<&>определяется как<<<>для выходных архивов и как<>>>входных архивов. «Полиморфное» поведение<&>позволяет использовать один и тот же шаблон для операций сохранения и загрузки. Это очень удобно в том смысле, что экономит массу набора текста и гарантирует, что сохранение и загрузка классовых данных всегда синхронизированы. Это ключ ко всей системе сериализации.

Свободная функция

// namespace selection
template<class Archive>
inline void serialize(
    Archive & ar, 
    my_class & t, 
    const unsigned int file_version
){
    ...
}

Пространства имен для переопределения свободных функций

• <boost::serialization>
• пространство имен класса архива
• пространство имен типа, сериализуемого

Обратите внимание, что на первый взгляд это предположение может показаться неправильным для компиляторов, которые реализуют двухфазный поиск. На самом деле библиотека сериализации использовала, возможно, слишком умный метод для поддержки этого правила даже для таких компиляторов. Те, кто заинтересован в дальнейшем изучении этого, найдут больше информации вserialization.hpp

Сериализация членов класса

{
    // save/load class member variables
    ar & member1;
    ar & member2;
}

Базовые классы

template<class Base, class Derived>
Base & base_object(Derived &d);

{
    // invoke serialization of the base class 
    ar & boost::serialization::base_object<base_class_of_T>(*this);
    // save/load class member variables
    ar & member1;
    ar & member2;
}

Обратите внимание, что этоНЕто же самое, что называть<serialize>функцией базового класса. Может показаться, что это работает, но обойдет определенный код, используемый для отслеживания объектов, и регистрации отношений, основанных на базе, и другой бухгалтерии, которая необходима для того, чтобы система сериализации функционировала так, как задумано. По этой причине все<serialize>членские функции должны быть<private>.

<const>Члены

    ar & const_cast<T &>(t);

Шаблоны

Пример, который показывает, как эта идея может быть реализована для ваших шаблонов классов, см.demo_auto_ptr.cpp. Это показывает, как может быть реализована ненавязчивая сериализация для шаблона<auto_ptr>из стандартной библиотеки.

Несколько более сложное добавление сериализации к стандартному шаблону можно найти в примереshared_ptr.hpp

В спецификации сериализации для шаблонов принято делить<serialize>на<load/save>пару. Обратите внимание, что макрос удобства, описанныйвыше, не полезен в этих случаях, поскольку число и тип аргументов класса шаблонов не будут соответствовать тем, которые используются при разделении<serialize>для простого класса. Вместо этого используйте синтаксис override.

Версия

{
    // invoke serialization of the base class 
    ar & boost::serialization::base_object<base_class_of_T>(*this);
    // save/load class member variables
    ar & member1;
    ar & member2;
    // if its a recent version of the class
    if(1 < file_version)
        // save load recently added class members
        ar & member3;
}

Расщепление<serialize>в Сохранить/Загрузить

Разделение функций

template<class Archive>
void save(Archive & ar, const unsigned int version) const
{
    // invoke serialization of the base class 
    ar << boost::serialization::base_object<const base_class_of_T>(*this);
    ar << member1;
    ar << member2;
    ar << member3;
}
template<class Archive>
void load(Archive & ar, const unsigned int version)
{
    // invoke serialization of the base class 
    ar >> boost::serialization::base_object<base_class_of_T>(*this);
    ar >> member1;
    ar >> member2;
    if(version > 0)
        ar >> member3;
}
template<class Archive>
void serialize(
    Archive & ar,
    const unsigned int file_version 
){
    boost::serialization::split_member(ar, *this, file_version);
}

BOOST_SERIALIZATION_SPLIT_MEMBER()

Расщепление свободных функций

namespace boost { namespace serialization {
template<class Archive>
void save(Archive & ar, const my_class & t, unsigned int version)
{
    ...
}
template<class Archive>
void load(Archive & ar, my_class & t, unsigned int version)
{
    ...
}
}}

namespace boost { namespace serialization {
template<class Archive>
inline void serialize(
    Archive & ar,
    my_class & t,
    const unsigned int file_version
){
    split_free(ar, t, file_version); 
}
}}

BOOST_SERIALIZATION_SPLIT_FREE(my_class)

Также обратите внимание, что<BOOST_SERIALIZATION_SPLIT_FREE>должно использоваться за пределами любого пространства имен.

Указатели

Для правильного сохранения и восстановления объекта с помощью указателя необходимо рассмотреть следующие ситуации:

1. Если один и тот же объект сохраняется несколько раз через разные указатели, необходимо сохранить только одну копию объекта.
2. Если объект загружается несколько раз через разные указатели, то должен быть создан только один новый объект и все возвращенные указатели должны указывать на него.
3. Система должна обнаружить случай, когда объект сначала сохраняется через указатель, а затем сам объект сохраняется. Без принятия дополнительных мер предосторожности загрузка приведет к созданию нескольких копий исходного объекта. Эта система выявляет этот случай при экономии и бросает исключение — см. ниже.
4. Объект производного класса может храниться через указатель на базовый класс. Истинный тип объекта должен быть определен и сохранен. При восстановлении необходимо создать правильный тип и правильно отлить его адрес в базовый класс. То есть нужно учитывать полиморфные указатели.
5. Указатели NULL должны быть вычтены при сохранении и восстановлены в NULL при десериализации.

Сохранение указателя:

1. определяют истинный тип указываемого объекта.
2. напишите специальный тег в архив
3. , если указанный объект еще не был записан в архив, сделайте это сейчас

1. читайте тег из архива.
2. определить тип создаваемого объекта
3. , если объект уже загружен, вернуть его адрес.
4. в противном случае, создать новый экземпляр объекта
5. считывать данные обратно при использовании операторов, описанных выше
6. возвращать адрес вновь созданного объекта.

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

Непо умолчанию Конструкторы

// load data required for construction and invoke constructor in place
template<class Archive, class T>
inline void load_construct_data(
    Archive & ar, T * t, const unsigned int file_version
){
    // default just uses the default constructor to initialize
    // previously allocated memory. 
    ::new(t)T();
}

Если такого конструктора по умолчанию нет, шаблоны функций<load_construct_data>и, возможно,<save_construct_data>должны быть переопределены. Вот простой пример:<

class my_class {
private:
    friend class boost::serialization::access;
    const int m_attribute;  // some immutable aspect of the instance
    int m_state;            // mutable state of this instance
    template<class Archive>
    void serialize(Archive &ar, const unsigned int file_version){
        ar & m_state;
    }
public:
    // no default construct guarentees that no invalid object
    // ever exists
    my_class(int attribute) :
        m_attribute(attribute),
        m_state(0)
    {}
};

namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(
    Archive & ar, const my_class * t, const unsigned int file_version
){
    // save data required to construct instance
    ar << t->m_attribute;
}
template<class Archive>
inline void load_construct_data(
    Archive & ar, my_class * t, const unsigned int file_version
){
    // retrieve data from archive required to construct new instance
    int attribute;
    ar >> attribute;
    // invoke inplace constructor to initialize instance of my_class
    ::new(t)my_class(attribute);
}
}} // namespace ...

Указатели на объекты производных классов

Регистрация

class base {
    ...
};
class derived_one : public base {
    ...
};
class derived_two : public base {
    ...
};
main(){
    ...
    base *b;
    ...
    ar & b; 
}

Получается, что вид сериализованного объекта зависит от того, является ли базовый класс (<base>в данном случае) полимофичным или нет. Если<base>не полиморфно, то есть не имеет виртуальных функций, то объект типа<base>будет сериализован. Информация в любом производном классе будет потеряна. Если это то, что желательно (обычно это не так), то никаких других усилий не требуется.

Если базовый класс полиморфен, то объект наиболее производного типа<derived_one>или<derived_two>в этом случае будет сериализован. Вопрос о том, какой тип объекта должен быть сериализован (почти) автоматически решается библиотекой.

Система «регистрирует» каждый класс в архиве, когда объект этого класса сериализуется и присваивает ему последовательное число. В следующий раз, когда объект этого класса будет сериализован в том же архиве, этот номер будет записан в архиве. Таким образом, каждый класс однозначно идентифицируется в архиве. При повторном прочтении архива каждый новый порядковый номер повторно связывается с прочитанным классом. Обратите внимание, что это означает, что «регистрация» должна происходить как во время сохранения, так и при нагрузке, так что таблица с целым классом, построенная на нагрузке, идентична таблице с целым классом, построенной на экономии. На самом деле, ключ ко всей системе сериализации заключается в том, что вещи всегда сохраняются и загружаются в одной последовательности. Это включает в себя «регистрацию».

Расширение нашего предыдущего примера:<

main(){
    derived_one d1;
    derived_two d2:
    ...
    ar & d1;
    ar & d2;
    // A side effect of serialization of objects d1 and d2 is that
    // the classes derived_one and derived_two become known to the archive.
    // So subsequent serialization of those classes by base pointer works
    // without any special considerations.
    base *b;
    ...
    ar & b; 
}

Если производный класс НЕ был автоматически «зарегистрирован», как описано выше,<unregistered_class>Исключение будет брошено при вызове сериализации.

Это может быть решено путем явной регистрации производного класса. Все архивы получены из базового класса, который реализует следующий шаблон:<

template<class T>
register_type();

main(){
    ...
    ar.template register_type<derived_one>();
    ar.template register_type<derived_two>();
    base *b;
    ...
    ar & b; 
}

Экспорт

Итак, у нас есть другой метод:<

#include <boost/serialization/export.hpp>
...
BOOST_CLASS_EXPORT_GUID(derived_one, "derived_one")
BOOST_CLASS_EXPORT_GUID(derived_two, "derived_two")
main(){
    ...
    base *b;
    ...
    ar & b; 
}

Обоснование

Полиморфные указатели производных классов никогда не могут быть объяснимы программой, поэтому обычно код для сериализации таких классов никогда не будет реализован. Таким образом, помимо включения строк экспортных ключей в архив,<BOOST_CLASS_EXPORT_GUID>явно инстанцирует код сериализации класса для всех классов архивов, используемых программой.

Селективное отслеживание

Может также случиться так, что даже если программа сериализуется через указатель, мы больше озабочены эффективностью, чем избегаем возможности создания дублирующихся объектов. Возможно, мы знаем, что дубликатов не будет. Также может быть, что создание нескольких дубликатов является доброкачественным и не стоит избегать, учитывая стоимость отслеживания дубликатов.<track_never>можно использовать.

Время выполнения Кастинг

#include <sstream>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
class base {
    friend class boost::serialization::access;
    //...
    // only required when using method 1 below
    // no real serialization required - specify a vestigial one
    template<class Archive>
    void serialize(Archive & ar, const unsigned int file_version){}
};
class derived : public base {
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int file_version){
        // method 1 : invoke base class serialization
        ar & boost::serialization::base_object<base>(*this);
        // method 2 : explicitly register base/derived relationship
        boost::serialization::void_cast_register<derived, base>(
            static_cast<derived *>(NULL),
            static_cast<base *>(NULL)
        )
    }
};
BOOST_CLASS_EXPORT_GUID(derived, "derived")
main(){
    //...
    std::stringstream ss;
    boost::archive::text_iarchive ar(ss);
    base *b;
    ar >> b; 
}

Для вызова этого шаблона в коде, составленном несоответствующими компиляторами, может использоваться следующий синтаксис:<

boost::serialization::void_cast_register(
    static_cast<Derived *>(NULL),
    static_cast<Base *>(NULL)
);

Ссылки

class object;
class my_class {
private:
    friend class boost::serialization::access;
    int member1;
    object & member2;
    template<class Archive>
    void serialize(Archive &ar, const unsigned int file_version);
public:
    my_class(int m, object & o) :
        member1(m), 
        member2(o)
    {}
};

namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(
    Archive & ar, const my_class * t, const unsigned int file_version
){
    // save data required to construct instance
    ar << t.member1;
    // serialize reference to object as a pointer
    ar << & t.member2;
}
template<class Archive>
inline void load_construct_data(
    Archive & ar, my_class * t, const unsigned int file_version
){
    // retrieve data from archive required to construct new instance
    int m;
    ar >> m;
    // create and load data through pointer to object
    // tracking handles issues of duplicates.
    object * optr;
    ar >> optr;
    // invoke inplace constructor to initialize instance of my_class
    ::new(t)my_class(m, *optr);
}
}} // namespace ...

Решетки

T t[4];
ar << t;
    ...
ar >> t;

Класс Сериализации Черты

Обертки Сериализации

Модели - Реализации Сериализации В библиотеке

#include <boost/serialization/list.hpp>

#include <list>

На момент написания этой статьи библиотека содержит сериализацию следующих классов повышения:

• факультативный
• вариант
• scoped_ptr
• shared_ptr
• auto_ptr (демо)

© CopyrightRobert Ramey2002-2004. Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресу http://www.boost.org/LICENSE_1_0.txt)

In the specification of serialization for templates, its common to split serialize into a load/save pair. Note that the convenience macro described above isn't helpful in these cases as the number and kind of template class arguments won't match those used when splitting serialize for a simple class. Use the override syntax instead.

Versioning

{
    // invoke serialization of the base class 
    ar & boost::serialization::base_object<base_class_of_T>(*this);
    // save/load class member variables
    ar & member1;
    ar & member2;
    // if its a recent version of the class
    if(1 < file_version)
        // save load recently added class members
        ar & member3;
}

Splitting serialize into Save/Load

Splitting Member Functions

template<class Archive>
void save(Archive & ar, const unsigned int version) const
{
    // invoke serialization of the base class 
    ar << boost::serialization::base_object<const base_class_of_T>(*this);
    ar << member1;
    ar << member2;
    ar << member3;
}
template<class Archive>
void load(Archive & ar, const unsigned int version)
{
    // invoke serialization of the base class 
    ar >> boost::serialization::base_object<base_class_of_T>(*this);
    ar >> member1;
    ar >> member2;
    if(version > 0)
        ar >> member3;
}
template<class Archive>
void serialize(
    Archive & ar,
    const unsigned int file_version 
){
    boost::serialization::split_member(ar, *this, file_version);
}

BOOST_SERIALIZATION_SPLIT_MEMBER()

Splitting Free Functions

namespace boost { namespace serialization {
template<class Archive>
void save(Archive & ar, const my_class & t, unsigned int version)
{
    ...
}
template<class Archive>
void load(Archive & ar, my_class & t, unsigned int version)
{
    ...
}
}}

namespace boost { namespace serialization {
template<class Archive>
inline void serialize(
    Archive & ar,
    my_class & t,
    const unsigned int file_version
){
    split_free(ar, t, file_version); 
}
}}

BOOST_SERIALIZATION_SPLIT_FREE(my_class)

Also note that BOOST_SERIALIZATION_SPLIT_FREE must be used outside of any namespace.

Pointers

To properly save and restore an object through a pointer the following situations must be addressed:

1. If the same object is saved multiple times through different pointers, only one copy of the object need be saved.
2. If an object is loaded multiple times through different pointers, only one new object should be created and all returned pointers should point to it.
3. The system must detect the case where an object is first saved through a pointer then the object itself is saved. Without taking extra precautions, loading would result in the creation of multiple copies of the original object. This system detects this case when saving and throws an exception - see below.
4. An object of a derived class may be stored through a pointer to the base class. The true type of the object must be determined and saved. Upon restoration the correct type must be created and its address correctly cast to the base class. That is, polymorphic pointers have to be considered.
5. NULL pointers must be dectected when saved and restored to NULL when deserialized.

Saving a pointer:

1. determine the true type of the object being pointed to.
2. write a special tag to the archive
3. if the object pointed to has not already been written to the archive, do so now

1. read a tag from the archive.
2. determine the type of object to be created
3. if the object has already been loaded, return its address.
4. otherwise, create a new instance of the object
5. read the data back in using the operators described above
6. return the address of the newly created object.

• Loading the same pointer object multiple times results in only one object being created, thereby replicating the original pointer configuration.
• Structures, such as collections of polymorphic pointers, are handled with no special effort on the part of users of this library.

Non-Default Constructors

// load data required for construction and invoke constructor in place
template<class Archive, class T>
inline void load_construct_data(
    Archive & ar, T * t, const unsigned int file_version
){
    // default just uses the default constructor to initialize
    // previously allocated memory. 
    ::new(t)T();
}

If there is no such default constructor, the function templates load_construct_data and perhaps save_construct_data will have to be overridden. Here is a simple example:

class my_class {
private:
    friend class boost::serialization::access;
    const int m_attribute;  // some immutable aspect of the instance
    int m_state;            // mutable state of this instance
    template<class Archive>
    void serialize(Archive &ar, const unsigned int file_version){
        ar & m_state;
    }
public:
    // no default construct guarentees that no invalid object
    // ever exists
    my_class(int attribute) :
        m_attribute(attribute),
        m_state(0)
    {}
};

namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(
    Archive & ar, const my_class * t, const unsigned int file_version
){
    // save data required to construct instance
    ar << t->m_attribute;
}
template<class Archive>
inline void load_construct_data(
    Archive & ar, my_class * t, const unsigned int file_version
){
    // retrieve data from archive required to construct new instance
    int attribute;
    ar >> attribute;
    // invoke inplace constructor to initialize instance of my_class
    ::new(t)my_class(attribute);
}
}} // namespace ...

Pointers to Objects of Derived Classes

Registration

class base {
    ...
};
class derived_one : public base {
    ...
};
class derived_two : public base {
    ...
};
main(){
    ...
    base *b;
    ...
    ar & b; 
}

It turns out that the kind of object serialized depends upon whether the base class (base in this case) is polymophic or not. If base is not polymorphic, that is if it has no virtual functions, then an object of the type base will be serialized. Information in any derived classes will be lost. If this is what is desired (it usually isn't) then no other effort is required.

If the base class is polymorphic, an object of the most derived type (derived_one or derived_two in this case) will be serialized. The question of which type of object is to be serialized is (almost) automatically handled by the library.

The system "registers" each class in an archive the first time an object of that class it is serialized and assigns a sequential number to it. Next time an object of that class is serialized in that same archive, this number is written in the archive. So every class is identified uniquely within the archive. When the archive is read back in, each new sequence number is re-associated with the class being read. Note that this implies that "registration" has to occur during both save and load so that the class-integer table built on load is identical to the class-integer table built on save. In fact, the key to whole serialization system is that things are always saved and loaded in the same sequence. This includes "registration".

Expanding our previous example:

main(){
    derived_one d1;
    derived_two d2:
    ...
    ar & d1;
    ar & d2;
    // A side effect of serialization of objects d1 and d2 is that
    // the classes derived_one and derived_two become known to the archive.
    // So subsequent serialization of those classes by base pointer works
    // without any special considerations.
    base *b;
    ...
    ar & b; 
}

If a derived class has NOT been automatically "registered" as described above, an unregistered_class exception will be thrown when serialization is invoked.

This can be addressed by registering the derived class explicitly. All archives are derived from a base class which implements the following template:

template<class T>
register_type();

main(){
    ...
    ar.template register_type<derived_one>();
    ar.template register_type<derived_two>();
    base *b;
    ...
    ar & b; 
}

Export

So we have another method:

#include <boost/serialization/export.hpp>
...
BOOST_CLASS_EXPORT_GUID(derived_one, "derived_one")
BOOST_CLASS_EXPORT_GUID(derived_two, "derived_two")
main(){
    ...
    base *b;
    ...
    ar & b; 
}

Instantiation

Polymorphic pointers of derived classes may never be referred to explictly by the program so normally code to serialize such classes would never be instantiated. So in addition to including export key strings in an archive, BOOST_CLASS_EXPORT_GUID explicitly instantiates the class serialization code for all archive classes used by the program.

Selective Tracking

It could also occur that even though a program serializes through a pointer, we are more concerned with efficiency than avoiding the the possibility of creating duplicate objects. It could be that we happen to know that there will be no duplicates. It could also be that the creation of a few duplicates is benign and not worth avoiding given the runtime cost of tracking duplicates. Again, track_never can be used.

Runtime Casting

#include <sstream>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
class base {
    friend class boost::serialization::access;
    //...
    // only required when using method 1 below
    // no real serialization required - specify a vestigial one
    template<class Archive>
    void serialize(Archive & ar, const unsigned int file_version){}
};
class derived : public base {
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int file_version){
        // method 1 : invoke base class serialization
        ar & boost::serialization::base_object<base>(*this);
        // method 2 : explicitly register base/derived relationship
        boost::serialization::void_cast_register<derived, base>(
            static_cast<derived *>(NULL),
            static_cast<base *>(NULL)
        )
    }
};
BOOST_CLASS_EXPORT_GUID(derived, "derived")
main(){
    //...
    std::stringstream ss;
    boost::archive::text_iarchive ar(ss);
    base *b;
    ar >> b; 
}

In order for this template to be invoked in code compiled by non-conforming compilers, the following syntax may be used:

boost::serialization::void_cast_register(
    static_cast<Derived *>(NULL),
    static_cast<Base *>(NULL)
);

References

class object;
class my_class {
private:
    friend class boost::serialization::access;
    int member1;
    object & member2;
    template<class Archive>
    void serialize(Archive &ar, const unsigned int file_version);
public:
    my_class(int m, object & o) :
        member1(m), 
        member2(o)
    {}
};

namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(
    Archive & ar, const my_class * t, const unsigned int file_version
){
    // save data required to construct instance
    ar << t.member1;
    // serialize reference to object as a pointer
    ar << & t.member2;
}
template<class Archive>
inline void load_construct_data(
    Archive & ar, my_class * t, const unsigned int file_version
){
    // retrieve data from archive required to construct new instance
    int m;
    ar >> m;
    // create and load data through pointer to object
    // tracking handles issues of duplicates.
    object * optr;
    ar >> optr;
    // invoke inplace constructor to initialize instance of my_class
    ::new(t)my_class(m, *optr);
}
}} // namespace ...

Arrays

T t[4];
ar << t;
    ...
ar >> t;

Class Serialization Traits

Serialization Wrappers

Models - Serialization Implementations Included in the Library

#include <boost/serialization/list.hpp>

#include <list>

As of this writing, the library contains serialization of the following boost classes:

• optional
• variant
• scoped_ptr
• shared_ptr
• auto_ptr (demo)

© Copyright Robert Ramey 2002-2004. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) [ORIG_END] -->

Статья Serialization - Serialization of Classes раздела может быть полезна для разработчиков на c++ и boost.

:: Главная :: ::