c++ - 为我将在 std::map 中使用的对象数组分配和释放内存的正确方法

Question

我有一个从数据库中检索的多边形集合，我希望将其存储在二叉树中以便快速访问。作为二叉树，我使用 std::map。

我创建了下面概述的这个解决方案，但我认为它不正确，因为我没有调用 free() 来释放 malloc() 分配的内存。

我的问题(问题):

1. 如果我只需要插入和访问这个映射的元素，使用 std::map 是否正确？我只想通过 ID 快速找到几何图形。
2. 在 std::map 中，我存储指向几何图形的指针，而不是存储几何图形本身。这是一个好主意吗？在我尝试自己存储几何图形之前，但后来我意识到 std::map 会复制对象，这会产生问题。
3. 在 ConvertSpatial2GPC(..) 方法中，我创建了 gpc_geometry 对象，它创建了引用，我在 gpc_free_polygon(..) 中释放了这些引用。但是我不能释放 gpc_geometry 对象本身，因为我当时没有对它的引用。

我使用以下结构:

typedef struct                      /* Polygon vertex structure          */
{
  double              x;            /* Vertex x component                */
  double              y;            /* vertex y component                */
} gpc_vertex;

typedef struct                      /* Vertex list structure             */
{
  int                 num_vertices; /* Number of vertices in list        */
  gpc_vertex         *vertex;       /* Vertex array pointer              */
} gpc_vertex_list;

typedef struct                      /* Polygon set structure             */
{
  int                 num_contours; /* Number of contours in polygon     */
  int                *hole;         /* Hole / external contour flags     */
  gpc_vertex_list    *contour;      /* Contour array pointer             */
} gpc_polygon;

typedef std::map<long, gpc_polygon*> layer;

我的工作流程如下:

1. 从数据库中加载项目
2. 调用返回图层的 initializeLayer() 方法(参见前面的 typedef)
3. ... 使用图层 ...
4. 调用方法 freeLayer() 释放图层使用的内存

几何对象初始化代码:

layer initializeLayer() {
    //... database connection code

    //find the count of objects in database
    int count = ...

    //helper object for loading from database
    spatial_obj* sp_obj = NULL;

    //initialize a array to hold the objects
    gpc_polygon* gpc_objects;
    gpc_objects = (gpc_polygon*)malloc(sizeof(gpc_polygon) * count);

    layer myLayer;

    int i = 0;

    //... query database
    while(db.Fetch()) {
        id = db.GetLongData(0);
        db.GetSDO_Object(&sp_obj); //load from database
        db.ConvertSpatial2GPC(sp_obj, &gpc_mullad[i]); //convert polygon to GPC format
        //insert a pair (ID->pointer to the geometry)
        myLayer.insert(layer::value_type(id, &gpc_objects[i]);
        i++;
    }

    return layer;
}

释放层代码:

void freeLayer(layer myLayer) {
    for (layer::iterator it = myLayer.begin(); it != myLayer.end(); ++it) {
        gpc_free_polygon(it->second); //frees the memory from this geometry object
    }
}

释放几何对象的代码:

void gpc_free_polygon(gpc_polygon *p)
{
    int c;

    for (c= 0; c < p->num_contours; c++) {
        FREE(p->contour[c].vertex);

    FREE(p->hole);
    FREE(p->contour);
    p->num_contours= 0;
}

Answer 1

我认为我让事情变得更复杂了。

我真的不需要 std::map 来存储指针。我可以改为询问数据库中的多边形，以便它们已经按 ID 排序。然后我可以将多边形存储在静态结构(数组或 vector )中。当我需要通过其 ID 查找元素时，我将只使用二进制搜索算法来查找它(无论如何，这是对数时间，就像二叉树使用的搜索算法一样)。

因此，我的方法 initializeLayer() 将返回一个数组或 vector ，我将在程序结束时释放它们。

编辑:我发现我不必自己实现二进制搜索。有一个类:std::binary_search。链接:Binary search algorithm

EDIT2:所以，这就是我最终得到的结果:

对象结构

typedef struct {
    long id;
    gpc_polygon gpc_obj;
} object;

层次结构

typedef std::vector<muld*> layer;

几何对象初始化代码:

layer initializeLayer() {
    //... database connection code

    //find the count of objects in database
    int count = ...

    //helper object for loading from database
    spatial_obj* sp_obj = NULL;
    object* object_ptr = NULL;

    layer myLayer;
    myLayer.reserve(count);

    int i = 0;

    //... query database
    while(db.Fetch()) {
        id = db.GetLongData(0);
        db.GetSDO_Object(&sp_obj); //load from database

        object_ptr = new object;
        object_ptr->id = id;
        db.ConvertSpatial2GPC(sp_obj, &object_ptr->gpc_obj);
        myLayer.push_back(object_ptr);
        i++;
    }

    return layer;
}

释放层代码:

void freeLayer(layer myLayer) {
    for(std::vector<int>::size_type i = 0; i != myLayer.size(); i++) {
        gpc_free_polygon(&myLayer[i]->gpc_obj);
        delete myLayer[i];
    }
}

二分查找代码:

我发现 std::binary_search 只返回是否找到对象。 std::lower_bound() 来拯救!

//Create empty object for searching
object* searched_obj = new obj;
object* found_obj = NULL;
searched_obj->id = id;
layer::iterator it;
it = std::lower_bound(myLayer.begin(), myLayer.end(), searched_obj, obj_comparer);
if(it != kiht.end()) {
    found_obj = *it;

    if(found_obj->id != id) {
        //Error!
    }
} else {
    //Error!
}
//Release memory
delete searched_obj;

比较对象的函数

bool obj_comparer(object *a, object  *b) {
    return a->id < b->id;
}