【步兵 工具篇】二進制讀寫 源碼

【步兵 工具篇】二進制讀寫 源碼 by EOS.

這是之前漏掉的，放一章太長了，在這裏補上。
使用方法參考 之前的文章：當二進制遇到模版

#include <assert.h>
#include <fstream>

#define StaticMemSize 1024*32

#define BinModeOpen s_MemNow = s_MemZero
#define quickWrite(p) es::writeBin(&s_MemNow, p)
#define quickRead(p) p = es::readBin(&s_MemNow, p)
#define BinModeClose s_MemEnd = s_MemNow; s_MemNow = NULL
#define memClear memset(s_MemZero, 0, StaticMemSize)
#define quickOpen(p) es::readFileToMem(p, s_MemZero)
#define quickSave(p) es::saveMemToFile(p, s_MemZero, s_MemEnd)

namespace es
{
    typedef unsigned char lit;
    namespace BinType
    {
        static int INT = 0;
        static short SHORT = 0;
        static lit LIT = 0x00;
        static std::string STRING = "";
    };

    static char* s_MemZero = nullptr;
    static char* s_MemNow = nullptr;
    static char* s_MemEnd = nullptr;
    char* getMemZero()
    {
        if (!s_MemZero)
        {
            s_MemZero = new char[StaticMemSize];
        }
        return s_MemZero;
    }

    //讀取模版
    template <class T>
    T readBin(char**  p, T t) { assert(false && "readBin error"); return t; }

    template <>
    int readBin(char**  p, int t)
    {
        int ret = 0;
        ret |= (lit)**p;    ++(*p); ret <<= 8;
        ret |= (lit)**p;    ++(*p); ret <<= 8;
        ret |= (lit)**p;    ++(*p); ret <<= 8;
        ret |= (lit)**p;    ++(*p);
        return ret;
    }

    template <>
    short readBin(char**  p, short t)
    {
        short ret = **p; ++(*p);    ret <<= 8;
        ret |= **p;     ++(*p);
        return ret;
    }

    template <>
    lit readBin(char**  p, lit t)
    {
        lit ret = **p; ++(*p);
        return ret;
    }

    template <>
    std::string readBin(char**  p, std::string t)
    {
        std::string ret;
        while (**p)
        {
            ret.push_back(**p);
            ++(*p);
        }
        //ret.push_back('\0');
        ++(*p);
        return ret;
    }


    //寫入模版
    template <class T>
    void writeBin(char**  p, T t) { assert(false && "writeBin error"); };

    template <>
    void writeBin(char**  p, int t)
    {
        **p = (t & 0xff000000) >> 24;   ++(*p);
        **p = (t & 0x00ff0000) >> 16;   ++(*p);
        **p = (t & 0x0000ff00) >> 8;    ++(*p);
        **p = (t & 0x000000ff);         ++(*p);
    }

    template <>
    void writeBin(char**  p, short t)
    {
        **p = (t & 0xff00) >> 8; ++(*p);
        **p = (t & 0x00ff);      ++(*p);
    }

    template <>
    void writeBin(char**  p, lit t)
    {
        **p = t; 
        ++(*p);
    }

    template <>
    void writeBin(char**  p, const char* t)
    {
        while (*t)
        {
            **p = *t;
            ++(*p);
            ++t;
        }
        **p = '\0';
        ++(*p);
    }

    void writeBin(char**  p, const std::string& s)
    {
        const char* t = s.c_str();
        writeBin(p, t);
    }

    template<class T>
    fpos_t getFileSize(T& fs)
    {
        fs.seekg(0, ios::end);
        auto fileSize = fs.tellg().seekpos();
        fs.seekg(0);
        return fileSize;
    }

    void saveMemToFile(const char* file, char* pStart, char* pEnd)
    {
        std::ofstream fout;
        fout.open(file, std::ios::binary);
        fout.write(pStart, pEnd - pStart);
        fout.close();
    }

    void readFileToMem(const char* file, char* pStart)
    {
        std::ifstream fin;
        fin.open(file, std::ios::binary);
        auto fileSize = getFileSize(fin);
        fin.read(pStart, fileSize);
        fin.close();
    }
};

/** Data Quick Create*/
#define CRDATE1(className, K, V) \
struct className \
{ \
K V; \
}; \
void flush_##className(const className& t) \
{ \
    quickWrite(t.##V); \
} \
void parse_##className(className& t) \
{ \
    quickRead(t.##V); \
}

#define CRDATE2(className, K, V, K2, V2) \
struct className \
{ \
K V; \
K2 V2; \
}; \
void flush_##className(const className& t) \
{ \
    quickWrite(t.##V); \
    quickWrite(t.##V2); \
} \
void parse_##className(className& t) \
{ \
    quickRead(t.##V); \
    quickRead(t.##V2); \
}

—-標準結局！

See Again~
之前
真愛無價，歡迎打賞~