我要做的是首先将键(因为您只想要返回这些键)提取到矢量中,然后排序如下:

std::vector<baseObject*> out;
std::transform(myMap.begin(), myMap.end(), std::back_inserter(out), [](std::pair<Object*, baseObject*> p) { return p.first; });
std::sort(out.begin(), out.end(), [&myMap](baseObject* lhs, baseObject* rhs) { return myMap[lhs].componentID < myMap[rhs].componentID; });

如果您的汇编器不支持 lambdas, 请将其重写为自由函数或函数对象 。 我只是使用 lambdas 来保持简洁 。

就性能而言,我很可能在最初的矢量中 reservation 有足够的空间,而不是让它逐渐扩大。

(也注意到我测试过代码 所以它可能需要一点小小小小小小小小小小)

此外,我不知道这张地图应该代表什么,但持有一张地图,其中关键类型和价值类型都是指针<它们真的 设置了我的“坏C+++ ” 感触。 它有人工记忆管理以及混乱(或根本不存在)所有权语义的味道。

您提到在 < code> list 中获取输出, 但 < code> victor 几乎肯定是一个更好的操作选项, 所以我使用这个选项。 只有这样, < code> list 才会更可取。 只有当您无意在列表上反复转动时, 并且如果您需要保证在修改列表后指示器和传译器保持有效时, 才会使用此选项 。

首先,我不会使用std:: list ,而是使用std::victor。现在,作为执行两个操作的特殊问题:生成容器,按你的标准排序。

// Extract the data:
std::vector<Object*> v;
v.reserve( m.size() );
std::transform( m.begin(), m.end(), 
                std::back_inserter(v),
                []( const map<Object*, baseObject*>::value_type& v ) {
                     return v.first;
                } );
// Order according to the values in the map
std::sort( v.begin(), v.end(), 
           [&m]( Object* lhs, Object* rhs ) {
               return m[lhs]->id < m[rhs]->id;
           } );

如果没有 C++11, 您需要创建真菌而不是羊羔, 如果您坚持返回 < code>>std: list , 那么您应该使用 < code>std:: list< & gt; : :: sort( 比较器) 。 请注意, 这可能是无效的。 如果性能是一个问题( 在您得到此工作后, 您的配置并知道这实际上是一个瓶颈), 您可能需要考虑使用中间的 < code> map<int, Object@gt; :

std::map<int,Object*> mm;
for ( auto it = m.begin(); it != m.end(); ++it )
   mm[ it->second->id ] = it->first;
}
std::vector<Object*> v;
v.reserve( mm.size() );                  // mm might have less elements than m!
std::transform( mm.begin(), mm.end(), 
                std::back_inserter(v),
                []( const map<int, Object*>::value_type& v ) {
                     return v.second;
                } );

再说一遍,这可能比原始版本... 简介更快或更慢

我想你会做的很好 与:

GetObjectList(std::list<Object*> &objects)
{
  std::vector <Object*> vec;
  vec.reserve(map.size());
  for(auto it = map.begin(), it_end = map.end(); it != it_end; ++it)
    vec.push_back(it->second);
  std::sort(vec.begin(), vec.end(), [](Object* a, Object* b) { return a->ID < b->ID; });
  objects.assign(vec.begin(), vec.end());
}

这里如何做你所说的,“按基本对象.IDs的顺序排列”:

typedef std::map<Object*, baseObject*> MapType;
MapType mymap; // don t care how this is populated
               // except that it must not contain null baseObject* values.

struct CompareByMappedId {
    const MapType &map;
    CompareByMappedId(const MapType &map) : map(map) {}
    bool operator()(Object *lhs, Object *rhs) {
        return map.find(lhs)->second->ID < map.find(rhs)->second->ID;
    }
};

void GetObjectList(std::list<Object*> &objects) {
    assert(objects.empty()); // pre-condition, or could clear it
    // or for that matter return a list by value instead.

    // copy keys into list
    for (MapType::const_iterator it = mymap.begin(); it != mymap.end(); ++it) {
        objects.push_back(it->first);
    }
    // sort the list
    objects.sort(CompareByMappedId(mymap));
}

这不是非常有效的: 它在地图中搜索比严格需要的要多, 而std: list:: sort 的操纵列表节点可能比 std 略慢一点 :: sort 将用来操纵随机进入的指针容器。 但是, 那么, < code>std: list 本身对于大多数目的来说并不十分有效, 所以您希望设置一个要花费很多钱 。

如果您需要优化, 您可以创建一对 (int, object*) 的矢量, 这样您只需在地图上重复一次, 不需要查找事情。 排序对子, 然后将每对的第二个元素放入列表中。 这可能是一个不成熟的优化, 但实际上这是一个有效的把戏 。

我会创建一个新地图, 该地图有使用对象组件代号的类似标准。 从第一个地图( 仅通过迭代或 std: opplication in) 中弹出第二张地图 。 然后您就可以使用迭代器读取此地图 。

从使用矢量或列表(log(n)时间而不是恒定时间)插入角度来说,这具有略微的间接间接影响, 但它避免了在您创建了矢量或列表之后进行排序的需要, 而列表是好的 。

此外,您还可以在您的节目中稍后添加更多内容,而无需诉诸任何手段,就可以维持节目的秩序。

我不确定我完全理解你试图在地图中储存什么,但也许"http://www.cplusplus.com/reference/stl/map/"rel="nolfollow"看这里

std::map 的第三个模板模板参数 :: map 是一个不那么带给因子 。 也许你可以用它来排序插入时在地图中存储的数据 。 之后, 它将是一个直向前循环, 在地图复制器上弹出列表 。