提升multi_index_container、范围变异算法和恒常性

Question

我正在使用 boost multi_index_container，它由 equal_range 查询，并使用 range：：join 和 boost：：any_range
从函数返回的结果any_range 引用参数定义为对该类型的 const 引用 - 由于multi_index_container性质，必须为 const，不太确定引用。例：

typedef boost::any_range<TestData, boost::random_access_traversal_tag,
                         const TestData &, std::ptrdiff_t> TestRange;

现在我需要的是使用变异范围算法，如 boost：：sort、unique 等，由于范围内元素的恒定性，它们显然无法在范围内运行。
除了将元素复制到新容器中之外，还有什么解决方法吗？

编辑 1：
结构和 MIC 示例：

struct TestData {
  TestData()
      : m_strMem01("test"), m_intMem02(rand()),
        m_boolMem03(rand() < RAND_MAX / 2) {}
  std::string m_strMem01;
  int m_intMem02;
  bool m_boolMem03;
};
typedef boost::multi_index_container<
    TestData,
    bmi::indexed_by<
        bmi::random_access<bmi::tag<struct RndKey1>>,
        bmi::ordered_non_unique<
            bmi::tag<struct Key1>,
            bmi::composite_key<
                TestData,
                bmi::member<TestData, std::string, &TestData::m_strMem01>,
                bmi::member<TestData, bool, &TestData::m_boolMem03>>>,
        bmi::ordered_non_unique<
            bmi::tag<struct Key4>,
            bmi::composite_key<
                TestData,
                bmi::member<TestData, std::string, &TestData::m_strMem01>,
                bmi::member<TestData, bool, &TestData::m_intMem02>>>,
        bmi::ordered_non_unique<
            bmi::tag<struct Key2>,
            bmi::member<TestData, int, &TestData::m_intMem02>>,
        bmi::ordered_non_unique<
            bmi::tag<struct Key3>,
            bmi::member<TestData, bool, &TestData::m_boolMem03>>>>
    TestDataContainer;

Answer 1

好吧，一旦你有了你的范围，你真的无法对它进行排序或以某种方式重新排列它，因为元素的顺序是由索引固定的——这是由元素的恒定性强制执行的索引的绝对基本不变量，就像你会发现std::set一样。无需对外部容器进行完整复制，而是可以通过指针或对原始元素的引用创建更轻量级的视图，以后可以根据需要对其进行操作。这是一个示例，其中视图构造为元素的 std::vector s 的 std::reference_wrapper s：

住在科里鲁

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/range/algorithm/sort.hpp>
#include <boost/range/join.hpp>
#include <functional>
#include <iostream>
#include <vector>
using namespace boost::multi_index;
struct X
{
  int x,y;
};
std::ostream& operator<<(std::ostream& os,const X& a)
{
  return os<<"{"<<a.x<<","<<a.y<<"}";
}
typedef multi_index_container<
  X,
  indexed_by<
    ordered_non_unique<member<X,int,&X::x>>
  >
> multi_t;
struct view:std::vector<std::reference_wrapper<const X>>
{
  using base=std::vector<std::reference_wrapper<const X>>;
  template<typename InputIterator>
  view(InputIterator first,InputIterator last):base(first,last){}
  template<typename InputIterator>
  view(const std::pair<InputIterator,InputIterator> p):base(p.first,p.second){}  
};
int main()
{
  multi_t m={{0,1},{0,0},{0,2},{1,3},{1,1},{2,0},{2,1}};
  view v1=m.equal_range(0); // elements with x==0
  view v2=m.equal_range(2); // elements with x==2
  auto v3=boost::range::join(v1,v2); // join them
  boost::range::sort(v3,[](const X& a,const X& b){return a.y<b.y;}); // sort them by y
  for(const auto& x:v3)std::cout<<x<<" "; // output
}

输出：

{0,0} {2,0} {0,1} {2,1} {0,2} 

Answer 2

听起来好像

你根本不希望你的数据在multi_index容器中。multi_index容器（顾名思义）旨在存储不可变的数据，同时针对该数据维护多个索引（或具有约束的视图）。

如果您希望能够更新数据的一部分，则可以将其mutable，但必须确保mutable部分不参与索引构造。

如果您真正想做的是改变数据并生成新的索引，那么您有 2 个选项 - 删除并重新插入或（更好）不使用 boost：：multi_index。

一种方法是使用向量并维护自己的临时索引。

例如，字符串向量中唯一条目的索引（为简单起见）：

vector<const string*> unique_stable_index(const vector<string>& data)
{
    struct less_ptr {
        bool operator()(const string* l, const string* r) const {
            return *l < *r;
        }
    };
    vector<const string*> result;
    set<const string*, less_ptr> seen;
    for (const auto& s : data) {
        if(seen.insert(&s).second)
            result.push_back(&s);
    }
    return result;
}