C 把这个过程抽象出来值得吗？

我有以下内存布局：

typedef struct map_obj_s
{
    thing_t**       things;

    linedef_t**     linedefs;

    sidedef_t**     sidedefs;

    vertex_t**      vertices;

    segment_t**     segments;

    ssector_t**     subsectors;

    node_t*         node_tree;

    sector_t**      sectors;

    int32_t         lump_counts[ MAP_LUMP_COUNT ];
}
map_obj_t;

问题是，我基本上对每种数据类型重复了完全相同的过程，除了node_树和lump_counts成员

下面是重复的结果：

map_obj_t* Map_Read( lumpbuffer_t* map_lump )
{
    int32_t lump_counts[ MAP_LUMP_COUNT ];

    __GetLumpCounts( map_lump, lump_counts );

    // laziness
    const lumpinfo_t* const mlumps = map_lump->lumps;

    FILE* mapfile   = Wad_GetFilePtr();

    map_obj_t* map  = Mem_Alloc( 1, sizeof( map_obj_t ) );

    // allocate buffers

    map->things     = Mem_Alloc( lump_counts[ LUMP_THINGS ],   sizeof( thing_t* ) );
    map->linedefs   = Mem_Alloc( lump_counts[ LUMP_LINEDEFS ], sizeof( linedef_t* ) );
    map->sidedefs   = Mem_Alloc( lump_counts[ LUMP_SIDEDEFS ], sizeof( sidedef_t* ) );
    map->vertices   = Mem_Alloc( lump_counts[ LUMP_VERTICES ], sizeof( vertex_t* ) );
    map->segments   = Mem_Alloc( lump_counts[ LUMP_SEGMENTS ], sizeof( segment_t* ) );
    map->subsectors = Mem_Alloc( lump_counts[ LUMP_SSECTORS ], sizeof( ssector_t* ) );
    map->node_tree  = Mem_Alloc( lump_counts[ LUMP_NODES ], sizeof( node_t ) );
    map->sectors    = Mem_Alloc( lump_counts[ LUMP_SECTORS ], sizeof( sector_t* ) );

    // parse things
    PARSE_LUMP( mapfile,
                map->things,
                sizeof( thing_t ),
                lump_counts[ LUMP_THINGS ],
                mlumps,
                LUMP_THINGS );

    // parse linedefs
    PARSE_LUMP( mapfile,
                map->linedefs,
                sizeof( linedef_t ),
                lump_counts[ LUMP_LINEDEFS ],
                mlumps,
                LUMP_LINEDEFS );


    // parse sidedefs
    PARSE_LUMP( mapfile,
                map->sidedefs,
                sizeof( sidedef_t ),
                lump_counts[ LUMP_SIDEDEFS ],
                mlumps,
                LUMP_SIDEDEFS );

    // parse vertices
    PARSE_LUMP( mapfile,
                map->vertices,
                sizeof( vertex_t ),
                lump_counts[ LUMP_VERTICES ],
                mlumps,
                LUMP_VERTICES );

    // parse segments
    PARSE_LUMP( mapfile,
                map->segments,
                sizeof( vertex_t ),
                lump_counts[ LUMP_SEGMENTS ],
                mlumps,
                LUMP_SEGMENTS );


    // parse subsectors
    PARSE_LUMP( mapfile,
                map->subsectors,
                sizeof( ssector_t ),
                lump_counts[ LUMP_SSECTORS ],
                mlumps,
                LUMP_SSECTORS );

    // parse nodes
    PARSE_LUMP( mapfile,
                map->node_tree,
                sizeof( node_t ),
                lump_counts[ LUMP_NODES ],
                mlumps,
                LUMP_NODES );


    // parse sectors
    PARSE_LUMP( mapfile,
                map->sectors,
                sizeof( sector_t ),
                lump_counts[ LUMP_SECTORS ],
                mlumps,
                LUMP_SECTORS );

    memcpy( map->lump_counts, lump_counts, sizeof( int32_t ) * MAP_LUMP_COUNT );

    return map;
}

以及

PARSE_LUMP

宏：

#define PARSE_LUMP( wad_fileptr, data, data_size, count, lumps_ptr, lump_type ) \
    do {                                                                        \
                                                                                \
        Mem_AllocBuffer( ( generic_buffer_t ) ( data ), ( data_size ), ( count ) ); \
                                                                                \
        fseek( ( wad_fileptr ),                                                 \
               ( lumps_ptr )[ ( lump_type ) ].address_offset,                   \
               SEEK_SET );                                                      \
                                                                                \
        for ( int32_t i = 0; i < count; ++i )                                   \
        {                                                                       \
            fread( ( data )[ i ], ( data_size ), 1, ( wad_fileptr ) );          \
        }                                                                       \
                                                                                \
    } while( 0 )                                                                \

#定义解析块（wad文件服务器、数据、数据大小、计数、块、块类型）\
做{\
\
Mem_AllocBuffer（（通用缓冲区）（数据），（数据大小），（计数））\
\
fseek（（wad_文件服务器）\
（集总ptr）[（集总类型）]。地址偏移\
搜索集）\
\
对于（int32_t i=0；i

---

要点

---

我想把这个抽象出来是不对的吗？当然，它是可读的，但是它的思想是由很多代码组成的。我不是一个很棒的C程序员（这是我第一个真正的/严肃的项目），但是我有C++的经验。在C++方面，模板很容易，但在C中，我只限于<代码> Value*/Cuff>和宏函数。序列化似乎是一种可能性，但所有这些的问题似乎都指向这样一个事实：我的缓冲区有指向指针的指针这样做有什么意义吗，或者我只是在浪费时间，甚至是在费事吗？更不用说我甚至确定如何从序列化结构中动态分配内存。

我想你所做的一切都是可行的，但我认为没有理由分配并分别读取每组块，如果您事先知道块的数量及其大小，则可以分配所需的所有内存，一次性读取整个文件，然后只需将每个指针设置为其各自块集的开始（偏移），如下所示：

//first set of lumps
map->things = map_data;
//increment pointer
map_data += lump_counts[ LUMP_THINGS ] * sizeof( thing_t );

//second set of lumps
map->linedefs = map_data;
map_data += lump_counts[ LUMP_LINEDEFS ] * sizeof( linedefs_t );
...

---

我强烈建议让

PARSE_LUMP

成为一个函数，并让编译器决定是否要内联它。不过，我不知道该怎么做……你知道如何编写宏，但不知道如何编写函数？！不，lol。宏中的

data

参数的类型完全是任意的，必须作为指向指针的指针接收。如果我使用一个

void**

，它会起作用吗？我想我明白你的意思了；我主要关心的是动态分配。也就是说，事物是

事物的类型**

；每个块类型都有任意数量的块…那么，我是否可以让块成员成为指向内存缓冲区的单个指针，每个都？@blissfreak是的，基本上，你需要分配一个足够大的缓冲区，以便只保存一次所有块，并且你可以一次读取所有块，并将每个指针设置到各自块集的开始处。这不会导致碎片问题或其他问题吗？@blissfreak如果碎片是指内存不连续，那么不，事实上，您的方法分配了许多小内存块（不一定是连续的）导致更多碎片。明白了。谢谢，这真的简化了事情。