C++ boost:：具有随机访问和有序唯一性的多索引容器_C++_Boost_Random Access_Multi Index

C++ boost:：具有随机访问和有序唯一性的多索引容器

c++ boost

C++ boost:：具有随机访问和有序唯一性的多索引容器,c++,boost,random-access,multi-index,C++,Boost,Random Access,Multi Index,我在使用随机访问和orderd_unique同时工作时遇到了一个问题。（我很抱歉问这么长的问题，但我想我应该举个例子……）这里有一个例子：假设我想在工厂中生产N个对象，对于每个对象我都有一个需要满足的需求（这个需求在创建多索引时就知道了）。在我的算法中，我得到了中间结果，我将其存储在以下类中： class intermediate_result { private: std::vector<int> parts; // which parts are prod

我在使用随机访问和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
};

class中间结果
{
私人：
std:：vector parts；//生产哪些零件
int used_time；//生产需要多长时间
ValueType max_value；//它值多少钱
};

向量

部分

描述了生成的对象（其长度为N，在字典上比我的coresp需求向量小！）——对于每个这样的向量，我也知道使用的时间。此外，我还得到了生成对象的向量的值

我得到了另一个约束，所以我不能生成每个对象-我的算法需要在一个数据结构中存储几个

中间结果

-对象。这里使用的是<>代码> Boo:：使用多个索引容器，因为一对<代码>部分<代码>和<代码>使用时间描述了一个唯一的<代码>中间的结果< /代码>（并且它应该在我的数据结构中是唯一的），但是<代码> Max值> /代码>是我必须考虑的另一个索引，因为我的算法总是需要具有最高

max\u值的中间结果

因此，我尝试将boost:：multi_index_container
与ordered_unique
一起用于我的“parts&used_time-pair”，将ordered_non_unique
用于我的max_value
（不同的中间结果
-对象可能具有相同的值）
问题是：谓词需要确定哪些“部分和使用的时间对”更小，它在我的部分
-向量上使用std:：lexicographic\u compare
，因此对于许多中间结果-对象来说速度非常慢。
但有一个解决方案：我对每个对象的需求并不是很高，因此我可以将中间结果唯一地存储在每个可能的部分上，通过其使用时间
例如：如果我有一个需求向量（2,3,1）
，那么我需要一个存储（2+1）*（3+1）*（1+1）=24个可能的部分向量的数据结构，并且在每个这样的条目上都有不同的使用时间，它们必须是唯一的！（存储最短时间是不够的-例如：如果我的附加约束是：完全满足给定的生产时间）
但是如何将随机访问
-索引与有序唯一
-索引结合起来呢？

（在这一点上没有帮助我。）
要使用两个索引，您可以编写以下内容：
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>
    >
  >
>

index\u by<
随机存取，
有序_唯一<
复合_键
中间结果，
委员:，
成员
>
>
>

您可以使用组合键
首先比较使用的时间
，只有在必要时才使用向量
。除此之外，请记住，您可以使用成员函数作为索引。
（我必须使用自己的答案来编写代码块-抱歉！）
带有使用时间
和部分的组合键
（正如Kirill V.Lyadvinsky所建议的）基本上就是我已经实现的。我想去掉部分
-向量的词典比较
假设我以某种方式存储了所需的需求，那么我可以编写一个简单的函数，它在随机访问数据结构中返回正确的索引，如下所示：
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);
    }
}

如果这是可能的，并且我使用所有可能的部分
-向量初始化了多索引（即，在我上面的评论中，我会在我的数据结构中推送24个空映射），这是否找到了给定的中间结果在恒定时间内的正确条目（在使用get\u index
计算正确的索引之后）？

我不得不问这个问题，因为我不太明白随机访问
索引是如何与有序唯一
索引相联系的
但是谢谢你迄今为止的回答
 哦，我忘了提到：如果我在向量之前测试使用的时间，那么“parts&used_time-pair”唯一性的谓词不会更快。此外，我尝试使用散列的_unique
而不是有序的_unique
——但我必须将向量和使用的_时间推到一个字符串中才能使用散列（生成的多_索引速度较慢）。是否有更好的方法使用散列或使用自己的随机访问数据结构（保证唯一性）与其他排序索引（最大值）链接？您好，谢谢您的回答，但这是否会禁止对不同的部分-向量使用相同的时间？我的意思是：只有向量和使用的时间对应该是唯一的（而不是时间本身），然后使用组合键。更新了我的答案。举个例子：我可以编写一个自己的数据结构，其中每个可能的部分向量有24个条目（如上面的例子），每个条目中都有一个std:：map
。这些映射可以为空（如果未找到此类中间结果）。但是，给定部分向量的使用时间是唯一的。但我也必须搜索最高的max_值！所以我想用multi_index_容器的随机访问索引来构建这种数据结构。。。（哦，请阅读您对composite\u-key
-的评论-我将对此进行研究-谢谢！！）正如您所建议的，使用返回（唯一）索引的成员函数，这种方法会更好。有了它，我就可以防止使用词典学的\u 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>
    >
  >
>