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 与最高的 max_value.

所以我尝试使用 boost::multi_index_container 和 ordered_unique<> 对于我的“零件和使用时间对”和 ordered_non_unique<> 为了我的 max_value （不同的 intermediate_result- 对象可能具有相同的值）。

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

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

但我如何结合 random_access<>-索引与 ordered_unique<>-指数？
(实施例11 在这件事上没有帮助我..）

Answer 1

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

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

假设我以某种方式存储了 required_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！是否可以写这样的东西来防止 lexicographical_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<> 指数..

但感谢您迄今为止的回答！

Answer 2

要使用两个指数，你可以写：

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。除此之外，记住，你可以使用成员函数作为索引。