C++ 自定义二进制资源文件

Question

我花了无数小时搜索有关此类主题的信息。我正在使用 C++ 中的 SDL 编写自己的自定义游戏引擎来获得乐趣。我正在尝试创建一个自定义二进制文件来管理我的游戏资源。到目前为止，在存储我放置在文件中的每个“类型”对象时，我还无法让 vector 发挥作用。所以我放弃了使用 vector 的想法，转而使用数组。我在下面有两个示例，其中我同时使用了 vector 或数组。所以，首先我为文件创建一个标题。这是结构:

    struct Header
{
    const char* name;   // Name of Header file
    float version;      // Resource version number
    int numberOfObjects;
    int headerSize;     // The size of the header

};

然后在创建 header 之后，我有另一个结构，它定义了对象如何存储在内存中。在这里:

struct ObjectData{

    int id;
    int size;
    const char* name;
    // std::vector<char> data; // Does not work very well
    // unsigned char* data;    // Also did not 

    // Also does not work, because I do not know the size yet until I have the data.
    // char data[]         

};

这个结构的主要问题是 vector 不能正常工作，unsigned char 指针一直给我带来问题，char 数据数组(用于十六进制存储)不起作用，因为我的编译器不喜欢变量数组。

最后的结构是我的资源文件结构。

struct ResourceFile
{
    Header header;

    int objectCount;
    // Again, vectors giving me issues because of how they are constructed internally
    // std::vector<ObjectData> objectList;
    // Below does not work because, again, no variable data types;
    // ObjectData objects[header.numberOfObjects]


};

我的目标是能够将单个结构写入二进制文件。像这样:

    Header header;

    header.name = "Resources.bin";
    header.version = 1.0f;
    header.headerSize = sizeof(header);

    //vector<char> Object1 = ByteReader::LoadFile("D:\\TEST_FOLDER\\test.obj");
    //vector<char> Object2 = ByteReader::LoadFile("D:\\TEST_FOLDER\\test.obj");

    ObjectData cube;
    cube.id = 0;
    cube.name = "Evil Cubie";
    cube.data = ByteReader::LoadFile("D:\\TEST_FOLDER\\test.obj");
    cube.size = sizeof(cube.id) + sizeof(cube.name) + cube.data.size();

    ofstream resourceFile("D:\\TEST_FOLDER\\Resources.bin", ios::out|ios::app|ios::binary);

    resourceFile << header.name << header.version << header.headerSize;;
    resourceFile << cube.id << cube.name << cube.size;
    for each (char ch in cube.data)
    {
        resourceFile << ch;
    }


    resourceFile.close();

    /*
    ObjectData cube2;
    cube.id = 1;
    cube.name = "Ugle Cubie";
    for each (char ch in Object1)
    {
        cube.object.push_back(ch);
    }
    */


    //resourceFile.data.push_back(cube);
    //resourceFile.data.push_back(cube2);

    //resourceFile.header.numberOfObjects = resourceFile.data.size();


    //FILE* dat = fopen(filename, "wb");
    //fwrite(&resourceFile, sizeof(resourceFile), 1, dat);   // <-- write to resource file
    //fclose(dat);

正如您在上面注意到的，我尝试了两种不同的方法。我尝试的第一种方法是使用旧的 fwrite。第二种方法甚至不以二进制形式写入它，即使我告诉计算机通过 ofstream 接受的标志这样做。

我的目标是让代码像这样流畅地工作:

ResourceFile resourceFile;

resourceFile.header.name = "Resources.bin";
resourceFile.header.version = 1;
resrouceFile.header.numberOfObjects = 2;
resourceFile.header.headerSize = sizeof(resourceFile.header);

ObjectData cube;
ObjectData cube2;


resourceFile.data.push_back(cube);
resourceFile.data.push_back(cube2);

resourceFile.header.numberOfObjects = resourceFile.data.size();


FILE* dat = fopen(filename, "wb");
fwrite(&resourceFile, sizeof(resourceFile), 1, dat);   // <-- write to resource file
fclose(dat);

仍然没有雪茄。任何人有任何指示(没有双关语)或资源管理器的适当示例吗？

Answer 1

这是我的专长之一，所以开始吧。围绕这一点有一整套编程学派，但我遵循的基本规则是:

1) 对具有“恒定”布局的事物使用 FIXED-LENGTH 结构。
这些是文件的标志位、指示子记录数量的字节等。尽可能多地将文件内容放入这些结构中——它们非常有效，尤其是与良好的 I/O 系统结合使用时.

您可以使用预处理器宏“#pragma pack(1)”将结构与字节边界对齐:

#ifdef WINDOWS
#pragma pack(push)
#endif
#pragma pack(1)

struct FixedSizeHeader {
   uint32 FLAG_BYTES[1];   // All Members are pointers for a reason
   char   NAME[20];
};

#ifdef WINDOWS
#pragma pack(pop)
#endif
#ifdef LINUX
#pragma pack()
#endif

2) 创建一个基类，纯接口(interface)，名称如“Serializable”。他是您的高级 API，用于将整个文件对象暂存到原始内存中和从原始内存中暂存出来。

class Serializable { // Yes, the name comes from Java. The idea, however, predates it
public:
   // Choose your buffer type- char[], std::string, custom
   virtual bool WriteToBinary(char* buffer) const = 0;
};

注意:要支持静态“加载”，您需要所有“可序列化”都具有额外的静态函数。有几种(非常不同的)方法来支持它，由于 C++ 没有“虚拟静态”，因此语言本身无法强制执行。

3) 创建用于管理每种文件类型的聚合类。它们的名称应与文件类型相同。根据文件结构，在您深入研究固定结构之前，每个文件可能依次包含更多“聚合器”类。

这是一个例子:

class GameResourceFile : public Serializable
{
private:
    // Operator= and the copy ctor should point to the same data for files,
    // since that is what you get with FILE*
protected:
    // Actual member variables- allows specialized (derived) file types direct access
    FixedSizeHeader* hdr;     // You don't have to use pointers here
    ContentManager*  innards; // Another aggregator- implements "Serializable"

    GameResourceFile(FixedSizeHeader* hdr, ContentManager* innards)
       : hdr(hdr), innards(innards) {}
    virtual ~GameResourceFile() { delete hdr; delete innards; }
public:
    virtual bool WriteToBinary(char* outBuffer) const 
    {
        // For fixed portions, use this
        memcpy(outBuffer, hdr, sizeof(FixedSizeHeader)); // This is why we 'pack'
        outBuffer += sizeof(FixedSizeHeader);            // Improve safety...
        return innards->WriteToBinary(outBuffer);
    }

    // C++ doesn't enforce this, but you can via convention
    static GameResourceFile* Load(const char* filename)
    {
        // Load file into a buffer- You'll want your own code here
        // Now that's done, we have a buffer
        char* srcContents;
        FixedSizeHeader* hdr = new FixedSizeHeader();
        memcpy(hdr, srcContents, sizeof(FixedSizeHeader));
        srcContents += sizeof(FixedSizeHeader);

        ContentManager* innards = ContentManager::Load( srcContents); // NOT the file
        if(!innards) {
           return 0;
        }
        return new GameResourceFile(hdr, innards);
    }
};

注意这是如何工作的——每个部分负责将自身序列化到缓冲区中，直到我们得到可以通过 memcpy() 添加的“原始”结构(您可以使所有组件成为“可序列化”类)。如果任何片段添加失败，调用将返回“false”，您可以中止。

我强烈建议使用像“引用对象”这样的模式来避免内存管理问题。然而，即使您不这样做，您现在也为用户提供了一种很好的一站式购物方法来从文件加载数据对象:

GameResourceFile* resource = GameResourceFile::Load("myfile.game");
if(!resource) { // Houston, we have a problem
   return -1;
}

最好的办法是将所有用于此类数据的低级操作和检索 API 添加到“GameResourceFile”。然后任何用于将更改提交到磁盘等的低级状态机协调都本地化到 1 个对象。