C++テンプレートや多型

Question

とシリアライザ（簡単にするため、シリアライザは書き込みとデシリアライザは、呼ばれると呼ばれますが、を読む）

私は許可されていないライブラリを最初からC++ゲーム・シリアライザを書いています。

私が主に気になるのは、読み書きを同期させておくことです（読み込み値は書き込まれた値と同じでなければなりません）。したがって、Packerは両方のタスクを処理し、列挙型で指定されます。

私が持っているどのような私は、私は、これはC++で可能ではないですけど、私は何を探していますがエレガントな方法である

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 

を行うことができるようにしたいどのような

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 
} 

この問題に対処する私はすでにタイプ消去を認識していますが、私は解決策のファンではありません。

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