查找所有排序在Boost

Find All Sorted in Boost

本文关键字：Boost 排序 查找      更新时间：2023-10-16

使用Boost网站上提供的示例:http://www.boost.org/doc/libs/1_55_0/libs/multi_index/example/basic.cpp，我学会了如何使用迭代器通过索引获取元素。然而，我希望得到所有匹配的一个索引和排序的另一个。

例如，在给定的示例中，我想获得所有姓名为"John"的员工，但返回的结果按年龄排序。到目前为止，当我按名称获取时，我返回的是第一次出现"John"的迭代器，等等，但是除了记录插入的顺序外，它们的返回方式没有顺序。

请帮忙!

有关代码:

/* Boost.MultiIndex basic example.
 *
 * Copyright 2003-2008 Joaquin M Lopez Munoz.
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See http://www.boost.org/libs/multi_index for library home page.
 */
#if !defined(NDEBUG)
#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
#endif
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
using boost::multi_index_container;
using namespace boost::multi_index;
/* an employee record holds its ID, name and age */
struct employee
{
  int         id;
  std::string name;
  int         age;
  employee(int id_,std::string name_,int age_):id(id_),name(name_),age(age_){}
  friend std::ostream& operator<<(std::ostream& os,const employee& e)
  {
    os<<e.id<<" "<<e.name<<" "<<e.age<<std::endl;
    return os;
  }
};
/* tags for accessing the corresponding indices of employee_set */
struct id{};
struct name{};
struct age{};
/* see Compiler specifics: Use of member_offset for info on
 * BOOST_MULTI_INDEX_MEMBER
 */
/* Define a multi_index_container of employees with following indices:
 *   - a unique index sorted by employee::int,
 *   - a non-unique index sorted by employee::name,
 *   - a non-unique index sorted by employee::age.
 */
typedef multi_index_container<
  employee,
  indexed_by<
    ordered_unique<
      tag<id>,  BOOST_MULTI_INDEX_MEMBER(employee,int,id)>,
    ordered_non_unique<
      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>,
    ordered_non_unique<
      tag<age>, BOOST_MULTI_INDEX_MEMBER(employee,int,age)> >
> employee_set;
template<typename Tag,typename MultiIndexContainer>
void print_out_by(
 const MultiIndexContainer& s,
 Tag* =0 /* fixes a MSVC++ 6.0 bug with implicit template function parms */
)
{
  /* obtain a reference to the index tagged by Tag */
  const typename boost::multi_index::index<MultiIndexContainer,Tag>::type& i=
    get<Tag>(s);
  typedef typename MultiIndexContainer::value_type value_type;
  /* dump the elements of the index to cout */
  std::copy(i.begin(),i.end(),std::ostream_iterator<value_type>(std::cout));
}

int main()
{
  employee_set es;
  es.insert(employee(0,"Joe",31));
  es.insert(employee(1,"Robert",27));
  es.insert(employee(2,"John",40));
  /* next insertion will fail, as there is an employee with
   * the same ID
   */
  es.insert(employee(2,"Aristotle",2387));
  es.insert(employee(3,"Albert",20));
  es.insert(employee(4,"John",57));
  /* list the employees sorted by ID, name and age */
  std::cout<<"by ID"<<std::endl;
  print_out_by<id>(es);
  std::cout<<std::endl;
  std::cout<<"by name"<<std::endl;
  print_out_by<name>(es);
  std::cout<<std::endl;
  std::cout<<"by age"<<std::endl;
  print_out_by<age>(es);
  std::cout<<std::endl;
  return 0;
}

有两种方法:

1:将第二个索引替换为基于(name,age)复合键的索引:

typedef multi_index_container<
  employee,
  indexed_by<
    ordered_unique<
      tag<id>,  member<employee,int,&employee::id>>,
    ordered_non_unique<
      tag<name>,
      composite_key<
        employee,
        member<employee,std::string,&employee::name>,
        member<employee,int,&employee::age>
      >
    >,
    ordered_non_unique<
      tag<age>, member<employee,int,&employee::age>>
  >
> employee_set;
int main()
{
  employee_set es={
    {0,"John",31},{1,"Robert",27},{2,"John",57},
    {5,"John",2387},{3,"Albert",20},{4,"John",40}};
  for(auto p=es.get<name>().equal_range("John");p.first!=p.second;++p.first){
    std::cout<<*(p.first);
  }
}

2:排序结果:

template<typename Iterator>
std::vector<std::reference_wrapper<const employee>>
sort_by_age(std::pair<Iterator,Iterator> p)
{
  std::vector<std::reference_wrapper<const employee>> v(p.first,p.second);
  std::sort(v.begin(),v.end(),
    [](const employee& e1,const employee& e2){return e1.age<e2.age;});
  return v;
}
int main()
{
  employee_set es={
    {0,"John",31},{1,"Robert",27},{2,"John",57},
    {5,"John",2387},{3,"Albert",20},{4,"John",40}};
  for(auto e:sort_by_age(es.get<name>().equal_range("John"))){
    std::cout<<e;
  }
}

哪个更好?#1在没有进一步后处理的情况下给出了期望的结果，但是插入到索引中(稍微)慢一些，因为比较标准比按名称进行比较的代价更高。#2有后处理的缺点，但可以与年龄以外的排序标准一起使用(与#1一起使用，它是在定义时固定的第二个键)。

相关文章：