C++ сериализатора с шаблоном и полиморфизмом

Question

(Для простоты, сериализатор будет называться записью и десериализатор будет называться чтения)

Я пишу C++ игры сериалайзер с нуля, без библиотеки допускается.

Основная проблема, которую я имею, заключается в том, чтобы сохранить синхронизацию чтения и записи (значения чтения должны быть такими же, как и записанные). Таким образом, Packer обрабатывает обе задачи и указан с перечислением.

Что я имею

enum PackerType { 
    WRITE, 
    READ 
} 

template <PackerType PType> 
class Packer { 
    char *buffer; // Packer will write here 
    uint32_t index; 

    template <typename T> 
    void Pack(T & value); // Calls appropriate functions depending on PType 
} 

Что я хочу быть в состоянии сделать

class ElementToSerialize : ISeriablizable { 

    virtual void WriteAndRead(Packer & p) { 
     p.Pack(32); 
     p.Pack("Hello World"); 
    } 
} 

Packer<WRITE> wpacker; 
Packer<READ> rpacker; 
rpacker.buffer = wpacker.buffer; 

WriteAndRead(wpacker); // Will write everything in wpacker.buffer 
WriteAndRead(rpacker); // Will read wpacker.buffer 

Так я знаю, что это не возможно в C++, но то, что я ищу элегантный способ решения этой проблемы. Я уже знаю о стирании стилей, но я не поклонник этого решения.

Answer 1

Как насчет начиная с чем-то например:

class IPacker 
{ 
public: 
    virtual void Pack(int& value) = 0; 
    virtual void Pack(float& value) = 0; 
} 

class ISeriablizable 
{ 
public: 
    virtual void Serialize(IPacker & p) = 0; 
} 

class WritePacker : public IPacker 
{ 
    char* buffer; 
    int index = 0; 
public: 
    WritePacker(char* buffer) : buffer(buffer) {} 
    void Pack(int& value) override { /* write to buffer */ } 
    void Pack(float& value) override { /* write to buffer */ } 
} 

class ReadPacker : public IPacker 
{ 
    char* buffer; 
    int index = 0; 
public: 
    ReadPacker(char* buffer) : buffer(buffer) {} 
    void Pack(int& value) override { /* read from buffer */ } 
    void Pack(float& value) override { /* read from buffer */ } 
} 

class ElementToSerialize : public ISeriablizable 
{ 
    int x = 32; 
    std::string y = "Hello world"; 

    void Serialize(IPacker & p) override 
    { 
     p.Pack(x); 
     p.Pack(y); 
    } 
} 

Answer 2

Если это не является обязательным требованием, вы могли бы избежать использования шаблонов в целом, и просто хранить ли пакера read или write, чтобы вы знали его во время выполнения (пример):

class Packer { 
public: 
    enum Type { 
     READ, 
     WRITE 
    }; 

    char *buffer; // Packer will write here 
    uint32_t index; 
    Type type; 

    Packer(Type t) : type(t) {} 

    void Pack(int& value); 
    void Pack(float& value); 
    void Pack(std::string& value); 
    // etc... 
};