우리는 우리의 C ++ 객체가 영속성을 유지하기를 바랍니다.
모든 객체는 ‘상태’를 파일에 저장하고 프로세스가 시작될 때 읽는 방법을 알아야하므로 중단 된 부분부터 계속할 수 있습니다.
그러나 C ++의 직렬화 구현은 (C #과 달리) 사소한 것이 아니며 우리 모두가 의존하기를 원하지 않습니다
MFC 프레임 워크 또는 부스트 직렬화 (어떤 템플릿을 사용하여 거대한 실행 파일을 만들 수 있습니다!).
다음은 직렬화 구현에 대한 요점입니다.
1. 복제 가능한 객체에 대한 추상 클래스가 있어야합니다.
2. 클래스 이름을 가진 복제 가능한 객체를 만드는 팩토리 클래스가 있어야합니다.
(힌트 : 싱글 톤 구현 사용).
3. 템플릿을 전혀 사용할 필요가 없습니다!
4. C ++에 정적 생성자가 없기 때문에 클래스를 자동으로 factory에 등록하는 것은 쉽지 않습니다.
이 작업은 클래스에 정적 멤버를 추가하는 매크로로 수행 할 수 있습니다.
5. 객체를 어디에 저장했는지 모르기 때문에 추상 Archive 클래스가 있어야합니다.
(파일, 파이프, 메모리 ..).
6. auto_ptr을 사용하여 직렬화가 실패하거나 예외가 발생할 경우 오브젝트를 삭제하십시오.
다음은 직렬화를위한 간단하지만 완전한 구현 프레임 워크입니다 . 파일 설명 :

• Dynamics.h – 복제 가능한 컬렉션의 싱글 톤 구현.
• Persistent.h / .cpp – Dynamics.h를 사용하는 직렬화 구현.

Dynamics.h :
먼저 복제 가능한 모든 객체에 대한 기본 클래스를 선언합니다. 모든 복제 가능한 클래스는 ‘Clonable’에서 파생되고 createObj메소드를 구현해야합니다 . createObj클래스의 새 객체를 반환해야합니다.

class Clonable
{
public:
    virtual ~Clonable() {}
    virtual Clonable* createObj() const = 0;
};

복제 가능한 객체의 컬렉션을 선언해야합니다. 이름을 주면 모든 복제 가능한 클래스의 인스턴스를 만들 수 있어야합니다.
예 :

string className = "MyComplexClass";
Clonable* instance = Clonables::Instance().create(className);
MyComplexClass* pCmplx = dynamic_cast<MyComplexClass*>(instance);

아래는 Cloneable 컬렉션 클래스입니다. 싱글 톤 구현에 주목하십시오.

class Clonables {
private:
    typedef map<string, const Clonable*> NameToClonable;
    NameToClonable __clonables;
private:
    Clonables() {}
    Clonables(const Clonables&);                 // Prevent copy-construction
    Clonables& operator=(const Clonables&);      //  Prevent assignment
    ~Clonables()
    {
        for(NameToClonable::const_iterator it = __clonables.begin(); it != __clonables.end(); it++){
            const Clonable* clone = it->second;
            delete clone;
        }
        __clonables.clear();
    }
public:
    static Clonables& Instance()
    {
        static Clonables instance;   // Guaranteed to be destroyed.                              
        return instance;    // Instantiated on first use.
    }
public:
    void addClonable(const char* className, const Clonable* clone)
    {
        string name = className;
        NameToClonable::const_iterator it = __clonables.find(name);
        if(it == __clonables.end()) {
            __clonables[name] = clone;
        }
    }
    Clonable* create(const char *className)
    {
        string name = className;
        NameToClonable::const_iterator it = __clonables.find(name);
        if(it == __clonables.end()) return NULL;
        const Clonable* clone = it->second;
        return clone->createObj();
    }
};

'<code>Clonables복제 가능한 파생 클래스는 ‘(우리의 복제 가능한 컬렉션)에 등록 할 수 있도록 다음 클래스의 정적 멤버를 추가 할 수 있습니다 .

class AddClonable {
public:
    AddClonable(const char* className, const Clonable* clone){
        Clonables::Instance().addClonable(className, clone);
    }
};

Persist.h :
우리는 우리의 끈질긴 사물이 어디에 저장 될지 확신하지 못합니다. 따라서 우리는 스트리밍을위한 기본 클래스 (저장 및로드 지원 포함)를 구현해야합니다. 아카이브는 파일이나 파이프 또는 객체를 저장하는 모든 것이 될 수 있습니다.

class Archive
{
private:
    bool _isStoring;
public:
    Archive(bool isStoring = true) : _isStoring(isStoring) {}
    virtual ~Archive() {}
    virtual void write(const void* buffer, size_t length) {}
    virtual void read(void* buffer, size_t length) {}
    Archive& operator<<(const string& str);
    Archive& operator>>(string& str);
    Archive& operator<<(int val);
    Archive& operator>>(int& val);
    bool isStoring() const { return _isStoring; }
    void setDirection(bool isStoring) { _isStoring = isStoring; }
};

STL iostream을 사용하는 특정 ‘Archive’클래스를 정의합시다.

class ArchiveFile: public Archive
{
private:
    iostream* _stream;
public:
    ArchiveFile(iostream* stream) : _stream(stream) {}
    virtual ~ArchiveFile() {}
    virtual void write(const void *buffer, size_t length);
    virtual void read (void* buffer, size_t length);
};

Persistent 클래스는 아래의 ‘Persistent’클래스에서 파생되고 ‘serialize’메소드를 구현합니다.
영속 객체는 또한 복제 가능 객체입니다.

class Persistent : public Clonable
{
public:
    virtual ~Persistent() {}
    static Persistent* load(Archive& stream);
    void store(Archive& stream) const;
protected:
    virtual void serialize(Archive& stream) {}
    virtual int version() const { return 0; }
};

우리는이 방법의 자동 구현 createObj과 자동 등록을 원합니다.
우리 클래스의 복제물 컬렉션에. 이것은 다음의 매크로 declerations와 함께 할 수 있습니다 :
PERSISTENT_DECL매크로 createObj는 우리를위한 ‘Clonable’클래스 의 메소드를 구현합니다 . 또한 AddClonable클래스에 정적 멤버를 추가합니다 . 이렇게하면 우리의 영속 클래스가 복제 가능한 컬렉션에 자체 등록됩니다. 이것은 .h 클래스 정의에 추가되어야합니다 (아래 예 참조).

#define PERSISTENT_DECL(className) \
public: \
virtual Clonable* createObj() const \
{ \
    return new className(); \
} \
private: \
static AddClonable _addClonable;

PERSISTENT_IMPL이 정적 멤버를 초기화합니다. 이것은 .cpp 클래스 구현에 추가되어야합니다.

#define PERSISTENT_IMPL(className) \
    AddClonable className::_addClonable(#className, new className());

사용법의 예 : Event.h는 'Event' 영속성이 있어야 하는 간단한 클래스를 정의합니다 .

class Event : public Persistent {
private:
 int _id;
public:
 Event() : _id(0) {}
 virtual ~Event() {}
 int getId() const { return _id; }
protected:
 virtual void serialize(Archive& stream)
 {
  if(stream.isStoring())
   stream << _id;
  else
   stream >> _id;
 }
 PERSISTENT_DECL(Event)
};

Event.cpp

#include "Event.h"

PERSISTENT_IMPL(Event)

우리는에 뛰어 전에 '<code>Archive' 및 '<code>Persistent' 클래스 구현, 여기에 동일한 내용을 가진 새로운 개체로 다시 읽어 후 바탕 화면에 바이너리 파일로 우리의 ‘이벤트’객체를 직렬화하는 방법의 예입니다.

void serialize_example()
{
    auto_ptr<Event> event(new Event());
    fstream file("C:\\Users\\Gilad\\Desktop\\try.data",
        ios::out | ios::in | ios::binary | ios::trunc);
    ArchiveFile stream(&file);
    if(! file)
        throw "Unable to open file for writing";
    event->store(stream);
    file.seekg(0, ios::beg);
    Event* newEvent = dynamic_cast<Event*>(Persistent::load(stream));
    event.reset(newEvent);
    file.close();
}

<event>Persistent.cpp :
우리는 기본적인 ‘int’및 ‘string’아카이브를 사용하여 구현을 시작합니다.

Archive& Archive::operator<<(int val)
{
     write(&val, sizeof(int));
     return *this;
}
Archive& Archive::operator>>(int& val)
{
     read(&val, sizeof(int));
     return *this;
}
Archive& Archive::operator<<(const string& str)
{
    int length = str.length();
    *this << length;
    write(str.c_str(), sizeof(char) * length);
    return *this;
}
Archive& Archive::operator>>(string& str)
{
    int length = -1;
    *this >> length;
    vector<char> mem(length + 1);
    char* pChars = &mem[0];
    read(pChars, sizeof(char) * length);
    mem[length] = NULL;
    str = pChars;
    return *this;
}

이제 특정 STL iostream 보관 구현을 추가해 보겠습니다.

void ArchiveFile::write(const void* buffer, size_t length)
{
    _stream->write((const char*)buffer,length);
    if(! *_stream)
        throw "ArchiveFile::write Error";
}
void ArchiveFile::read(void* buffer, size_t length)
{
    _stream->read((char*)buffer, length);
    if(! *_stream)
        throw "ArchiveFile::read Error";
}

이것은 영구 객체를 아카이브에 저장 하는 방법입니다 .

1. 개체의 클래스 이름을 저장하십시오.
2. 클래스의 버전을 저장하십시오.
3. 객체를 직렬화하도록 호출합니다.

void Persistent::store(Archive& stream) const
{
    string className = typeid(*this).name();
    className = className.substr(className.find(' ') + 1);
    stream << className;
    int ver = version();
    stream << ver;
    stream.setDirection(true);
    const_cast<Persistent *>(this)->serialize(stream);
}

다음은 아카이브에서 객체를 로드 하는 방법입니다 .

1. 아카이브에서 클래스 이름 읽기
2. cloneable 컬렉션과 간단한 캐스트를 사용하여 객체를 만듭니다.
3. 버전이 올바른지 확인하십시오.
4. 우리의 객체가 스스로를 비 직렬화하게하십시오.

auto_ptr의 사용에주의하십시오. (serialize 메소드와 같이) 예외가 발생하면 우리의 영속 객체가 삭제 될 것입니다.

Persistent* Persistent::load(Archive& stream)
{
    string className;
    stream >> className;
    Clonable* clone = Clonables::Instance().create(className.c_str());
    if(clone == NULL)
        throw "Persistent::load : Error creating object";
    auto_ptr<Clonable> delitor(clone);
    Persistent * obj = dynamic_cast<Persistent *>(clone);
    if(obj == NULL) {
        throw "Persistent::load : Error creating object";
    }
    int ver = -1;
    stream >> ver;
    if(ver != obj->version())
        throw "Persistent::load : unmatched version number";
    stream.setDirection(false);
    obj->serialize(stream);
    delitor.release();
    return obj;
}