boost::multi_index_container 具有 random_access 和ordered_unique

Question

我在使用 boost::multi_index_container 同时使用随机访问和 orderd_unique 时遇到问题。 （我很抱歉这个冗长的问题，但我认为我应该使用一个例子..）

这里有一个例子：假设我想在工厂中生产 N 个对象，并且对于每个对象我都有一个要满足的需求（这个需求是已知的）创建多索引时）。 好吧，在我的算法中，我得到了中间结果，我将其存储在以下类中：

class intermediate_result
{
private:
    std::vector<int>   parts;     // which parts are produced
    int                used_time; // how long did it take to produce

    ValueType          max_value; // how much is it worth
};

向量 parts 描述了生成的对象（其长度为 N，按字典顺序小于我的 coresp 需求向量） ！） - 对于每个这样的向量，我也知道used_time。此外，我还获得了生成对象的向量的值。

我有另一个约束，因此我无法生成每个对象 - 我的算法需要在数据结构中存储多个 intermediate_result 对象。这里使用了 boost::multi_index_container，因为 parts 和 used_time 对描述了一个唯一的 intermediate_result（并且它在我的数据结构中应该是唯一的），但 max_value 是我必须考虑的另一个索引，因为我的算法始终需要具有最高 的 intermediate_result最大值。

因此，我尝试将 boost::multi_index_container 与 ordered_unique<> 一起用于我的“parts&used_time-pair”，并使用 ordered_non_unique<> 进行我的 max_value （不同的 intermediate_result - 对象可能具有相同的值）。

问题是：决定哪个“parts&used_time-pair”较小所需的谓词在我的 parts 向量上使用 std::lexicographyal_compare ，因此是对于许多 intermediate_result 对象来说非常慢。 但会有一个解决方案：我对每个对象的需求不是那么高，因此我可以根据其used_time在每个可能的部分向量上存储唯一的中间结果。

例如：如果我有一个需求向量 ( 2 , 3 , 1) 那么我需要一个存储 (2+1)*(3+1)*(1 +1)=24 可能的部分向量以及每个此类条目上不同的used_times，它们必须是唯一的！ （存储最小的时间是不够的 - 例如：如果我的附加约束是：完全满足给定的生产时间）

但是如何将 random_access-index 与 结合起来order_unique<>-index?
（Example11 没有帮助我就这个..）

Answer 1

要使用两个索引，您可以编写以下内容：

indexed_by<
  random_access< >,      
  ordered_unique< 
    composite_key< 
      intermediate_result,
      member<intermediate_result, int, &intermediate_result::used_time>,
      member<intermediate_result, std::vector<int>, &intermediate_result::parts>
    >
  >
>

您可以首先使用 composite_key 来比较 used_time，然后仅在必要时使用 vector。除此之外，请记住您可以使用成员函数作为索引。

Answer 2

（我必须使用自己的答案来编写代码块 - 抱歉！）

带有 used_time 和 parts 的 composite_key （如 Kirill V. Lyadvinsky建议）基本上是我已经实现的。我想摆脱 parts-向量的字典比较。

假设我已经以某种方式存储了need_demand，那么我可以编写一个简单的函数，它在随机访问数据结构中返回正确的索引，如下所示：

int get_index(intermediate_result &input_result) const
{
    int ret_value  = 0;
    int index_part = 1;
    for(int i=0;i<needed_demand.size();++i)
    {
        ret_value  += input_result.get_part(i) * index_part;
        index_part *= (needed_demand.get_part(i) + 1);
    }
}

显然，这可以更有效地实现，并且这不是唯一可能的索引排序需要的需求。但是我们假设这个函数作为 intermediate_result 的成员函数存在！是否可以编写这样的内容来防止 lexicographyal_compare ？

indexed_by<
  random_access< >,      
  ordered_unique< 
    composite_key< 
      intermediate_result,
      member<intermediate_result, int, &intermediate_result::used_time>,
      const_mem_fun<intermediate_result,int,&intermediate_result::get_index>
    >
  >
>

如果这是可能的，并且我用所有可能的 parts-向量初始化了多重索引（即在上面的评论中，我会在我的数据结构中推送 24 个空映射），这是否找到了正确的在恒定时间内输入给定的 intermediate_result（使用 get_index 计算正确的索引后）？
我必须问这个问题，因为我不太明白 random_access<> 索引是如何与 ordered_unique<> 索引链接的。

但是谢谢你到目前为止你的答案！！