Boost.MultiIndex 键提取参考

随机访问索引

Boost.MultiIndex 参考

编译器特性

内容

• 键提取器
  • 链式指针
• 头文件 "boost/multi_index/key_extractors.hpp" 概要
• 头文件 "boost/multi_index/identity.hpp" 概要
  • 类模板 identity
• 头文件 "boost/multi_index/member.hpp" 概要
  • 类模板 member
  • 类模板 member_offset
  • 宏 BOOST_MULTI_INDEX_MEMBER
• 头文件 "boost/multi_index/mem_fun.hpp" 概要
  • 类模板 const_mem_fun
  • 类模板 cv_mem_fun、cref_mem_fun 和 cvref_mem_fun
  • 类模板 mem_fun
  • 类模板 volatile_mem_fun、ref_mem_fun 和 vref_mem_fun
  • 类模板 const_mem_fun_explicit 和 mem_fun_explicit
  • 宏 BOOST_MULTI_INDEX_CONST_MEM_FUN 和 BOOST_MULTI_INDEX_MEM_FUN
• 头文件 "boost/multi_index/global_fun.hpp" 概要
  • 类模板 global_fun
• 头文件 "boost/multi_index/composite_key.hpp" 概要
  • 类模板 composite_key
  • 类模板 composite_key_result
  • 相等性
    • 类模板 composite_key_equal_to
    • 类模板 composite_key_result_equal_to
    • std::equal_to 的 composite_key 结果特例化
  • 比较
    • 类模板 composite_key_compare
    • 类模板 composite_key_result_less
    • 类模板 composite_key_result_greater
    • std::less 的 composite_key 结果特例化
    • std::greater 的 composite_key 结果特例化
  • 哈希
    • 类模板 composite_key_hash
    • 类模板 composite_key_result_hash
    • boost::hash 的 composite_key 结果特例化
  • composite_key_result 的语义
• 头文件 "boost/multi_index/key.hpp" 概要
  • 别名模板 key

键提取器

键提取类由 基于键的索引 用于从 multi_index_container 的元素中获取索引键。一个 CopyConstructible 和 CopyAssignable 类 KeyFromValue 如果满足以下条件，则被称为类型 Type 的键提取器：

1. 定义了类型 KeyFromValue::result_type；
2. k1(ca) 已定义并返回一个可转换为 const KeyFromValue::result_type& 的值；
3. 如果 k2 是 k1 的副本，则 k1(ca) 与 k2(ca) 的值相同；

此外，如果满足以下额外条件，则 KeyFromValue 为读写键提取器：

1. remove_reference_t<KeyFromValue::result_type> 没有 `const` 限定符。
2. k1(a) 已定义并返回一个可转换为 KeyFromValue::result_type& 的值；
3. k1(a) 与 k1(const_cast<const Type&>(a)) 绑定到同一个对象；

Boost.MultiIndex 提供了十二个通用的键提取器：

• identity,
• member,
• const_mem_fun（以及三个 变体），
• mem_fun（以及三个 变体），
• global_fun 和
• composite_key,

链式指针

Boost.MultiIndex 提供的键提取器根据类型 Type 进行模板化，用于不仅从 Type 类型对象中提取键，还从 Boost.Ref 提供的引用包装器以及指向 Type（或 Type 的引用包装器）的链式指针中提取键：链式指针是任何类型 P，对于类型为 const P 的对象 p：

• *p 生成类型为 Type& 或 boost::reference_wrapper<Type> 的对象，或者
• *p 生成指向 Type 的链式指针，

头文件 "boost/multi_index/key_extractors.hpp" 概要

#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/global_fun.hpp>
#include <boost/multi_index/composite_key.hpp>

此头文件包含 Boost.MultiIndex 提供的所有键提取器。

头文件 "boost/multi_index/identity.hpp" 概要

namespace boost{

namespace multi_index{

template<typename T> struct identity;

} // namespace boost::multi_index 

} // namespace boost

类模板 identity

identity 是一个 键提取器，它充当什么也不做的恒等函子。

template<typename Type>
struct identity
{
  typedef Type result_type;

  // only provided if const ChainedPtr& is not convertible to const Type&
  template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;

  const Type& operator()(const Type& x)const; 
  Type&       operator()(Type& x)const; // only provided if Type is non-const

  // only provided if Type is non-const
  const Type& operator()(const reference_wrapper<const Type>& x)const; 

  // only provided if Type is const
  Type& operator()(
    const reference_wrapper<typename remove_const<Type>::type>& x)const; 

  Type& operator()(const reference_wrapper<Type>& x)const;
};

identity<Type> 是以下内容的模型：

• Type 的读写 键提取器，
• 键提取器 来自 reference_wrapper<const Type>，
• reference_wrapper<Type> 的读写 键提取器，
• 键提取器 来自指向 const Type 的任何 链式指针，
• Type 的任何 链式指针 的读写 键提取器。

identity 成员

要求：ChainedPtr 是指向 Type 的 链式指针 类型。
返回：对 x 指向的对象的引用。

返回：x。

返回：x。

返回：x.get()。

返回：x.get()。

返回：x.get()。

头文件 "boost/multi_index/member.hpp" 概要

namespace boost{

namespace multi_index{

template<class Class,typename Type,Type Class::*PtrToMember>
struct member;

template<class Class,typename Type,std::size_t OffsetOfMember>
struct member_offset; // deprecated

#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) implementation defined

} // namespace boost::multi_index 

} // namespace boost

类模板 member

member 是一个旨在访问类中给定成员的 键提取器。

template<class Class,typename Type,Type Class::*PtrToMember>
struct member
{
  typedef Type result_type;

  // only provided if const ChainedPtr& is not convertible to const Class&
  template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;

  const Type& operator()(const Class& x)const;
  Type&       operator()(Class& x)const; // only provided if Type is non-const
  const Type& operator()(const reference_wrapper<const Class>& x)const;
  Type&       operator()(const reference_wrapper<Class>& x)const;
};

PtrToMember 模板参数指定要提取的成员的特定 Type Class::* 指针。member<Class,Type,PtrToMember> 是以下内容的模型：

• Class 的 键提取器，如果 Type 没有 `const` 限定符，则为读写；
• 键提取器 来自 reference_wrapper<const Class>；
• 键提取器 来自 reference_wrapper<Class>，如果 Type 没有 `const` 限定符，则为读写；
• 键提取器 来自指向 const Class 的任何 链式指针；
• 键提取器 来自指向 Class 的任何 链式指针，如果 Type 没有 `const` 限定符，则为读写。

member 成员

要求：ChainedPtr 是指向 Type 的 链式指针 类型。
返回：对 x 指向的对象的引用。

返回：x.*PtrToMember。

返回：x.*PtrToMember。

返回：x.get().*PtrToMember。

返回：x.get().*PtrToMember。

类模板 member_offset

member_offset 的设计是为了克服一些遗留编译器的限制，目前已弃用。有关更多信息，请参阅 Boost.MultiIndex 的 旧版本。

宏 BOOST_MULTI_INDEX_MEMBER

BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName)

此宏的设计是为了作为遗留编译器的可移植性机制，在这些编译器中无法支持 member。因此，在现代环境中不再需要它，尽管一些用户可能仍然更喜欢它而不是普通的 member，因为它提供了稍微更简洁的语法。

头文件 "boost/multi_index/mem_fun.hpp" 概要

namespace boost{

namespace multi_index{

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const>
struct const_mem_fun;

template<
  class Class,typename Type,Type (Class::*PtrToMemberFunction)()const volatile
>
struct cv_mem_fun;

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const&>
struct cref_mem_fun;

template<
  class Class,typename Type,Type (Class::*PtrToMemberFunction)()const volatile&
>
struct cvref_mem_fun;

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()>
struct mem_fun;

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()volatile>
struct volatile_mem_fun;

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()&>
struct ref_mem_fun;

template<
  class Class,typename Type,Type (Class::*PtrToMemberFunction)()volatile&
>
struct vref_mem_fun;

template<
  class Class,typename Type,
  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction
>
struct const_mem_fun_explicit; // deprecated

template<
  class Class,typename Type,
  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction
>
struct mem_fun_explicit;       // deprecated

#define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \
implementation defined
#define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \
implementation defined

} // namespace boost::multi_index 

} // namespace boost

类模板 const_mem_fun

const_mem_fun 是一个 键提取器，它将调用类的给定常数成员函数的结果作为键返回。

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const>
struct const_mem_fun
{
  typedef typename remove_reference<Type>::type result_type;

  // only provided if const ChainedPtr& is not convertible to const Class&
  template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;

  Type operator()(const Class& x)const;
  Type operator()(const reference_wrapper<const Class>& x)const;
  Type operator()(const reference_wrapper<Class>& x)const;
};

PtrToMemberFunction 模板参数指定用于提取的特定 Type (Class::*PtrToMemberFunction)()const 常数成员函数指针。const_mem_fun<Class,Type,PtrToMemberFunction> 是以下内容的模型：

• 键提取器 来自 Class；
• 键提取器 来自 reference_wrapper<const Class>；
• 键提取器 来自 reference_wrapper<Class>；
• 键提取器 来自指向 const Class 的任何 链式指针；
• 键提取器 来自指向 Class 的任何 链式指针；

const_mem_fun 成员

要求：ChainedPtr 是指向 Type 的 链式指针 类型。
返回：(y.*PtrToMemberFunction)()，其中 y 是 x 指向的对象。

返回：(x.*PtrToMemberFunction)()。

返回：(x.get().*PtrToMemberFunction)()。

返回：(x.get().*PtrToMemberFunction)()。

类模板 cv_mem_fun、cref_mem_fun 和 cvref_mem_fun

这些 键提取器 是 const_mem_fun 的变体，在传递的成员函数为以下情况时使用：

• const volatile (cv_mem_fun)，
• const & 限定 (cref_mem_fun)，
• const volatile & 限定 (cvref_mem_fun)。

类模板 mem_fun

mem_fun 是一个 键提取器，它将调用类的给定成员函数的结果作为键返回。

template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()>
struct mem_fun
{
  typedef typename remove_reference<Type>::type result_type;

  // only provided if ChainedPtr& is not convertible to Class&
  template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;

  Type operator()(Class& x)const;
  Type operator()(const reference_wrapper<Class>& x)const;
};

PtrToMemberFunction 模板参数指定用于提取的特定成员函数指针 Type (Class::*PtrToMemberFunction)()。mem_fun<Class,Type,PtrToMemberFunction> 是以下内容的模型：

• 键提取器 来自 reference_wrapper<Class>；
• 键提取器 来自指向 Class 的任何 链式指针；

mem_fun 成员

要求：ChainedPtr 是指向 Type 的 链式指针 类型。
返回：(y.*PtrToMemberFunction)()，其中 y 是 x 指向的对象。

返回：(x.*PtrToMemberFunction)()。

返回：(x.get().*PtrToMemberFunction)()。

类模板 volatile_mem_fun、ref_mem_fun 和 vref_mem_fun

这些 键提取器 是 mem_fun 的变体，用于传递的成员函数为：

• volatile (volatile_mem_fun),
• &限定 (ref_mem_fun),
• volatile &限定 (vref_mem_fun).

类模板 const_mem_fun_explicit 和 mem_fun_explicit

这些提取器作为 MSVC++ 6.0 的一种解决方法提供，现在已弃用。有关更多信息，请参阅 Boost.MultiIndex 的旧版本。

宏 BOOST_MULTI_INDEX_CONST_MEM_FUN 和 BOOST_MULTI_INDEX_MEM_FUN

BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName)
BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName)

用于 const_mem_fun 和 mem_fun 的可移植性宏。虽然在现代编译器中不再需要，但一些用户可能仍然决定使用它们，因为它们提供了稍微更简洁的语法。

头文件 "boost/multi_index/global_fun.hpp" 概要

namespace boost{

namespace multi_index{

template<class Value,typename Type,Type (*PtrToFunction)(Value)>
struct global_fun;

} // namespace boost::multi_index 

} // namespace boost

类模板 global_fun

global_fun 是基于给定全局或静态成员函数的 键提取器，该函数接受基类型作为参数并返回关联的键。

template<class Value,typename Type,Type (*PtrToFunction)(Value)>
struct global_fun
{
  typedef typename remove_reference<Type>::type result_type;

  // Only provided under the following circumstances:
  //   - If Value is a reference to a constant type, only provided
  //     when const ChainedPtr& is not convertible to Value;
  //   - if Value is a reference to a non-const type, only provided
  //     when ChainedPtr& is not convertible to Value;
  //   - else, only provided when const ChainedPtr& is not
  //     convertible to const Value&.
  Type operator()(const ChainedPtr& x)const;
  
  // only provided if Value is a reference type
  Type operator()(Value x)const;

  // only provided if Value is not a reference type
  Type operator()(const Value& x)const;

  // only provided if Value is not a reference type
  Type operator()(const reference_wrapper<const Value>& x)const;

  // only provided if Value is a reference type
  Type operator()(
    const reference_wrapper<
      remove_reference<Value>::type>& x)const;

  // only provided if Value is not a reference type or is
  // a reference to a constant type
  Type operator()(
    const reference_wrapper<
      typename remove_const<
        typename remove_reference<Value>::type>::type>& x)const;
};

PtrToFunction 指定用于从某个 BaseType 提取类型为 Type 的键的特定函数。global_fun 支持以下函数签名：

• Type f(BaseType) (Value 为 BaseType),
• Type f(const BaseType&) (Value 为 const BaseType&),
• Type f(BaseType&) (Value 为 BaseType&).

• 键提取器，来自 reference_wrapper<BaseType>，
• 键提取器，来自指向 BaseType 的任何链式指针。

• 键提取器，来自 BaseType，
• 键提取器，来自 reference_wrapper<const BaseType>，
• 键提取器，来自指向 const BaseType 的任何链式指针。

global_fun 成员

要求：ChainedPtr 是指向 Value 的链式指针类型。
返回：PtrToFunction)(y)，其中 y 是 x 指向的对象。

返回：PtrToFunction(x)。

返回：PtrToFunction(x)。

返回：PtrToFunction(x.get())。

返回：PtrToFunction(x.get())。

返回：PtrToFunction(x.get())。

头文件 "boost/multi_index/composite_key.hpp" 概要

namespace boost{

namespace multi_index{

template<typename Value,typename KeyFromValue0,...,typename KeyFromValuen>
struct composite_key;

template<typename CompositeKey>
struct composite_key_result;
  
// comparison operators for composite_key_result:

// OP is any of ==,<,!=,>,>=,<=

template<typename CompositeKey1,typename CompositeKey2>
bool operator OP(
  const composite_key_result<CompositeKey1>& x,
  const composite_key_result<CompositeKey2>& y);

template<typename CompositeKey,typename... Values>
bool operator OP(
  const composite_key_result<CompositeKey>& x,
  const std::tuple<Values...>& y);

template<typename CompositeKey,typename... Values>
bool operator OP(
  const std::tuple<Values...>& x,
  const composite_key_result<CompositeKey>& y);

template<typename CompositeKey,typename Value0,...,typename Valuen>
bool operator OP(
  const composite_key_result<CompositeKey>& x,
  const boost::tuple<Value0,...,Valuen>& y);

template<typename Value0,...,typename Valuen,typename CompositeKey>
bool operator OP(
  const boost::tuple<Value0,...,Valuen>& x,
  const composite_key_result<CompositeKey>& y);

// equality functors:

template<typename Pred0,...,typename Predn>
struct composite_key_equal_to;
  
template<typename CompositeKeyResult>
struct composite_key_result_equal_to; // deprecated

// comparison functors:

template<typename Compare0,...,typename Comparen>
struct composite_key_compare;
  
template<typename CompositeKeyResult>
struct composite_key_result_less;     // deprecated

template<typename CompositeKeyResult>
struct composite_key_result_greater;  // deprecated

// hash functors:

template<typename Hash0,...,typename Hashn>
struct composite_key_hash;
  
template<typename CompositeKeyResult>
struct composite_key_result_hash;     // deprecated

} // namespace boost::multi_index

} // namespace boost

// specializations of external functors for composite_key_result:

namespace std{

template<typename CompositeKey>
struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >;

template<typename CompositeKey>
struct less<boost::multi_index::composite_key_result<CompositeKey> >;

template<typename CompositeKey>
struct greater<boost::multi_index::composite_key_result<CompositeKey> >;

} // namespace std

namespace boost{

template<typename CompositeKey>
struct hash<boost::multi_index::composite_key_result<CompositeKey> >;

} // namespace boost

类模板 composite_key

composite_key 是一个 键提取器，它返回多个键提取器的组合值，这些键提取器的类型在编译时指定。返回的对象类型为 composite_key_result<composite_key>。

template<typename Value,typename KeyFromValue0,...,typename KeyFromValuen>
struct composite_key
{
  typedef boost::tuple<KeyFromValue0,...,KeyFromValuen> key_extractor_tuple;
  typedef Value                                         value_type;
  typedef composite_key_result<composite_key>           result_type;

  composite_key(
    const KeyFromValue0& k0=KeyFromValue0(),
    ...
    const KeyFromValuen& kn=KeyFromValuen());

  composite_key(const key_extractor_tuple& x);

  const key_extractor_tuple& key_extractors()const;
  key_extractor_tuple&       key_extractors()

  // only provided if const ChainedPtr& is not convertible to const value_type&
  template<typename ChainedPtr>
  result_type operator()(const ChainedPtr& x)const;
  
  result_type operator()(const value_type& x)const;
  result_type operator()(const reference_wrapper<const value_type>& x)const;
  result_type operator()(const reference_wrapper<value_type>& x)const;
};

KeyFromValue0, ... , KeyFromValuen 是组合到复合键中的键提取器的类型。这些类型中的每一个都必须是从 Value 中提取键的 键提取器。必须至少提供一个键提取器。composite_key 实例化的键提取器的最大数量由实现定义。composite_key 在内部存储每个组成键提取器类型的对象。composite_key<Value,KeyFromValue0,...,KeyFromValuen> 是以下内容的模型：

• 键提取器，来自 Value，
• 键提取器，来自 reference_wrapper<const Value>，
• 键提取器，来自 reference_wrapper<Value>，
• 键提取器，来自指向 const Value 的任何链式指针，
• 键提取器，来自指向 Value 的任何链式指针。

composite_key 成员

效果：构造一个存储提供的键提取器对象的副本的 composite_key。

效果：构造一个存储在 x 中提供的键提取器对象的副本的 composite_key。

返回：对 composite_key 内部存储的持有键提取器的元组的常量引用。

返回：对 composite_key 内部存储的持有键提取器的元组的引用。

要求：ChainedPtr 是指向 result_type 的链式指针类型。
返回：取决于 *this 和 y 的 result_type 对象，其中 y 是 x 指向的对象。

返回：取决于 *this 和 x 的 result_type 对象。

返回：取决于 *this 和 x.get() 的 result_type 对象。

返回：取决于 *this 和 x.get() 的 result_type 对象。

类模板 composite_key_result

这是一个由 composite_key 实例化作为其提取键返回的不透明类型。

template<typename CompositeKey>
struct composite_key_result
{
  no public interface available
};

// comparison:
  
// OP is any of ==,<,!=,>,>=,<=

template<typename CompositeKey1,typename CompositeKey2>
bool operator OP(
  const composite_key_result<CompositeKey1>& x,
  const composite_key_result<CompositeKey2>& y);

template<typename CompositeKey,typename... Values>
bool operator OP(
  const composite_key_result<CompositeKey>& x,
  const std::tuple<Values...>& y);

template<typename CompositeKey,typename... Values>
bool operator OP(
  const std::tuple<Values...>& x,
  const composite_key_result<CompositeKey>& y);

template<typename CompositeKey,typename Value0,...,typename Valuen>
bool operator OP(
  const composite_key_result<CompositeKey>& x,
  const boost::tuple<Value0,...,Valuen>& y);

template<typename Value0,...,typename Valuen,typename CompositeKey>
bool operator OP(
  const boost::tuple<Value0,...,Valuen>& x,
  const composite_key_result<CompositeKey>& y);

符号

给定类型为 composite_key_result<CompositeKey> 的 x，我们使用以下符号：

• ck(x) 是与 x 关联的 CompositeKey 对象，
• v(x) 是与 x 关联的 CompositeKey::value_type 类型的对象，
• ki(x) = ck(x).key_extractors().get<i>()，即 ck(x) 的第 i 个键提取器，
• xi = ki(x)(v(x))，即由第 i 个键提取器从 v(x) 提取的键，
• length(x) 是 ck(x) 的键提取器数量。

• yi=get<i>(y),
• length(y) 是 y 的元素数量。

比较运算符

要求：length(x)==length(y)。表达式 xi==yi 对 [0,length(x)) 中的所有 i 均有效。
返回：当且仅当

xi==yi 对 [0,length(x)) 中的所有 i 均为真时返回 true。

复杂度：执行的键提取操作和比较次数不超过评估上述表达式所需的次数，从 i==0 开始。一旦确定结果为 false，则会短路评估。

要求：表达式 xi<yi 和 yi<xi 对 [0,min(length(x),length(y))) 中的所有 i 均有效。
返回：当且仅当存在 [0,min(length(x),length(y))) 范围内的某个 j，使得

!(xi<yi) && !(yi<xi) 对 [0,j) 中的所有 i 均为真，
  xj<yj.

复杂度：执行的键提取操作和比较次数不超过评估上述表达式所需的次数，从 i==0 开始。一旦确定结果为 false，则会短路评估。

(OP 为 !=、>、>=、<= 中的任何一个。)

要求：下面给出的表达式有效（对于所考虑的特定 OP）。
返回：当且仅当

!(x==y) (OP 为 !=),
  y< x (OP 为 >),
!(x< y) (OP 为 >=),
!(y< x) (OP 为 <=).

相等性

类模板 composite_key_equal_to

composite_key_equal_to 使用内部存储的基本相等谓词集合来测试 composite_key_result 实例化之间以及这些实例化与值元组之间的相等性。

template<typename Pred0,...,typename Predn>
struct composite_key_equal_to
{
  typedef boost::tuple<Pred0,...,Predn> key_eq_tuple;

  composite_key_equal_to(
    const Pred0& p0=Pred0(),
    ...
    const Predn& pn=Predn());

  composite_key_equal_to(const key_eq_tuple& x);

  const key_eq_tuple& key_eqs()const;
  key_eq_tuple&       key_eqs();

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const composite_key_result<CompositeKey1> & x,
    const composite_key_result<CompositeKey2> & y)const;
  
  template<typename CompositeKey,typename... Values>
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const std::tuple<Values...>& y)const;

  template<typename CompositeKey,typename... Values>
  bool operator()(
    const std::tuple<Values...>& x,
    const composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value0,...,typename Valuen>
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const boost::tuple<Value0,...,Valuen>& y)const;

  template<typename Value0,...,typename Valuen,typename CompositeKey>
  bool operator()(
    const boost::tuple<Value0,...,Valuen>& x,
    const composite_key_result<CompositeKey>& y)const;
};

Pred0, ... , Predn 是 composite_key_equal_to 存储的相等二元谓词的类型。这些谓词中的每一个都必须是 CopyConstructible 和 CopyAssignable。必须至少提供一个相等谓词。composite_key_equal_to 实例化的相等谓词的最大数量由实现定义。composite_key_equal_to 是 CopyConstructible 和 CopyAssignable。如果每个 Predi 本身都是 DefaultConstructible，它也是 DefaultConstructible。

请注意，正式来说，不需要 Predi 类型以任何明确的方式表现为相等谓词。但是，如果情况如此，则 composite_key_equal_to 的语义是明确定义的，如composite_key_result 的语义部分所解释。

符号

在下文中，我们使用与 composite_key_result相同的符号。

composite_key_equal_to 成员

效果：构造一个存储提供的相等谓词对象的副本的 composite_key_equal_to。

效果：构造一个存储在 x 中提供的相等谓词对象的副本的 composite_key_equal_to。

返回：对 composite_key_equal_to 内部存储的持有相等谓词对象的元组的常量引用。

返回：对 composite_key_equal_to 内部存储的持有相等谓词对象的元组的引用。

要求：length(x)==length(y)。表达式key_eqs().get<i>()(xi,yi) 和 key_eqs().get<i>()(yi,xi) 对[0,length(x))内的所有i都必须有效。
返回：当且仅当

key_eqs().get<i>()(xi,yi) 对[0,length(x))内的所有i都为真时返回true。

复杂度：执行的键提取操作和比较次数不超过评估上述表达式所需的次数，从 i==0 开始。一旦确定结果为 false，则会短路评估。

类模板 composite_key_result_equal_to

已弃用。请改用std::equal_to<CompositeKeyResult>。

std::equal_to 的 composite_key 结果特例化

std::equal_to<CompositeKeyResult>，其中CompositeKeyResult是composite_key_result的实例化，其行为类似于composite_key_equal_to的特例，其中提供的所有比较谓词都是std::equal_to的实例化。

namespace std{

template<typename CompositeKey>
struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >
{
  typedef 
    boost::multi_index::composite_key_result<
      CompositeKey>                           first_argument_type;
  typedef first_argument_type                 second_argument_type;
  typedef bool                                result_type;

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey1> & x,
    const boost::multi_index::composite_key_result<CompositeKey2> & y)const;
  
  template<typename CompositeKey,typename... Values>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const std::tuple<Values...>& y)const;

  template<typename CompositeKey,typename... Values>
  bool operator()(
    const std::tuple<Values...>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value0,...,typename Valuen>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const boost::tuple<Value0,...,Valuen>& y)const;

  template<typename Value0,...,typename Valuen,typename CompositeKey>
  bool operator()(
    const boost::tuple<Value0,...,Valuen>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;
};

} // namespace std

CompositeKeyResult必须是某种类型composite_key<KeyFromValue0,...,KeyFromValuen>的composite_key_result实例化。然后，std::equal_to<CompositeKeyResult>::operator() 等价于composite_key_equal_to<Pred0,...,Predn>::operator()，取

Predi = std::equal_to<KeyFromValuei::result_type>，对于所有i = 0,...,n。

除了composite_key_equal_to对Predi的要求外，这些类型还必须是DefaultConstructible（可默认构造）。std::equal_to<CompositeKeyResult>是DefaultConstructible、CopyConstructible（可复制构造）和CopyAssignable（可复制赋值）。

比较

类模板 composite_key_compare

composite_key_compare 使用内部存储的初级比较谓词集合来比较composite_key_result实例彼此之间以及与值元组的比较。

template<typename Compare0,...,typename Comparen>
struct composite_key_compare
{
  typedef boost::tuple<Compare0,...,Comparen> key_comp_tuple;

  composite_key_compare(
    const Compare0& c0=Compare0(),
    ...
    const Comparen& cn=Comparen());

  composite_key_compare(const key_comp_tuple& x);

  const key_comp_tuple& key_comps()const;
  key_comp_tuple&       key_comps();

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const composite_key_result<CompositeKey1> & x,
    const composite_key_result<CompositeKey2> & y)const;
  
  template<typename CompositeKey,typename... Values>
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const std::tuple<Values...>& y)const;

  template<typename CompositeKey,typename... Values>
  bool operator()(
    const std::tuple<Values...>& x,
    const composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value0,...,typename Valuen>
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const boost::tuple<Value0,...,Valuen>& y)const;

  template<typename Value0,...,typename Valuen,typename CompositeKey>
  bool operator()(
    const boost::tuple<Value0,...,Valuen>& x,
    const composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value>
  bool operator()(
    const composite_key_result<CompositeKey>& x,const Value& y)const;

  template<typename Value,typename CompositeKey>
  bool operator()(
    const Value& x,const composite_key_result<CompositeKey>& y)const;
};

Compare0, ... , Comparen 是composite_key_compare存储的比较二元谓词的类型。这些谓词必须是CopyConstructible和CopyAssignable。必须至少提供一个比较谓词。composite_key_compare 实例化的最大比较谓词数量由实现定义。composite_key_compare是CopyConstructible和CopyAssignable。如果每个Comparei本身都是DefaultConstructible，那么它也是DefaultConstructible。

请注意，从形式上讲，不要求Comparei类型以任何明确的方式表现为比较谓词。但是，如果情况如此，则composite_key_compare的语义定义良好，如关于composite_key_result语义的部分所述。

符号

在下文中，我们使用与 composite_key_result相同的符号。

composite_key_compare 成员

效果：构造一个存储所提供比较谓词副本的composite_key_compare。

效果：构造一个存储x中提供的比较谓词对象副本的composite_key_compare。

返回：对composite_key_compare内部存储的保存比较谓词对象的元组的常量引用。

返回：对composite_key_compare内部存储的保存比较谓词对象的元组的引用。

要求：表达式key_comps().get<i>()(xi,yi) 和 key_comps().get<i>()(yi,xi) 对[0,min(length(x),length(y)))内的所有i都必须有效。
返回：当且仅当存在 [0,min(length(x),length(y))) 范围内的某个 j，使得

!key_comps().get<i>()(xi,yi) && !key_comps().get<i>()(yi,xi)，对于[0,j)内的所有i，
 key_comps().get<j>()(xj,yj).

复杂度：执行的键提取操作和比较次数不超过评估上述表达式所需的次数，从 i==0 开始。一旦确定结果为 false，则会短路评估。

效果

return operator()(x,boost::make_tuple(boost::cref(y)));

效果

return operator()(boost::make_tuple(boost::cref(x)),y);

类模板 composite_key_result_less

已弃用。请改用std::less<CompositeKeyResult>。

类模板 composite_key_result_greater

已弃用。请改用std::greater<CompositeKeyResult>。

std::less 的 composite_key 结果特例化

std::less<CompositeKeyResult>，其中CompositeKeyResult是composite_key_result的实例化，其行为类似于composite_key_compare的特例，其中提供的所有比较谓词都是std::less的实例化。

namespace std{

template<typename CompositeKey>
struct less<boost::multi_index::composite_key_result<CompositeKey> >
{
  typedef
    boost::multi_index::composite_key_result<
      CompositeKey>                           first_argument_type;
  typedef first_argument_type                 second_argument_type;
  typedef bool                                result_type;

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey1> & x,
    const boost::multi_index::composite_key_result<CompositeKey2> & y)const;
  
  template<typename CompositeKey,typename... Values>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const std::tuple<Values...>& y)const;

  template<typename CompositeKey,typename... Values>
  bool operator()(
    const std::tuple<Values...>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value0,...,typename Valuen>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const boost::tuple<Value0,...,Valuen>& y)const;

  template<typename Value0,...,typename Valuen,typename CompositeKey>
  bool operator()(
    const boost::tuple<Value0,...,Valuen>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const Value& y)const;

  template<typename Value,typename CompositeKey>
  bool operator()(
    const Value& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;
};

} // namespace std

CompositeKeyResult必须是某种类型composite_key<KeyFromValue0,...,KeyFromValuen>的composite_key_result实例化。然后，std::less<CompositeKeyResult>::operator() 等价于composite_key_compare<Compare0,...,Comparen>::operator()，取

Comparei = std::less<KeyFromValuei::result_type>，对于所有i = 0,...,n。

除了composite_key_compare对Comparei的要求外，这些类型还必须是DefaultConstructible。std::less<CompositeKeyResult>是DefaultConstructible、CopyConstructible和CopyAssignable。

std::greater 的 composite_key 结果特例化

std::greater<CompositeKeyResult>，其中CompositeKeyResult是composite_key_result的实例化，其行为类似于composite_key_compare的特例，其中提供的所有比较谓词都是std::greater的实例化。

namespace std{

template<typename CompositeKey>
struct greater<boost::multi_index::composite_key_result<CompositeKey> >
{
  typedef
    boost::multi_index::composite_key_result<
      CompositeKey>                           first_argument_type;
  typedef first_argument_type                 second_argument_type;
  typedef bool                                result_type;

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey1> & x,
    const boost::multi_index::composite_key_result<CompositeKey2> & y)const;
  
  template<typename CompositeKey,typename... Values>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const std::tuple<Values...>& y)const;

  template<typename CompositeKey,typename... Values>
  bool operator()(
    const std::tuple<Values...>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value0,...,typename Valuen>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const boost::tuple<Value0,...,Valuen>& y)const;

  template<typename Value0,...,typename Valuen,typename CompositeKey>
  bool operator()(
    const boost::tuple<Value0,...,Valuen>& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;

  template<typename CompositeKey,typename Value>
  bool operator()(
    const boost::multi_index::composite_key_result<CompositeKey>& x,
    const Value& y)const;

  template<typename Value,typename CompositeKey>
  bool operator()(
    const Value& x,
    const boost::multi_index::composite_key_result<CompositeKey>& y)const;
};

} // namespace std

CompositeKeyResult必须是某种类型composite_key<KeyFromValue0,...,KeyFromValuen>的composite_key_result实例化。然后，std::greater<CompositeKeyResult>::operator() 等价于composite_key_compare<Compare0,...,Comparen>::operator()，取

Comparei = std::greater<KeyFromValuei::result_type>，对于所有i = 0,...,n。

除了composite_key_compare对Comparei的要求外，这些类型还必须是DefaultConstructible。std::greater<CompositeKeyResult>是DefaultConstructible、CopyConstructible和CopyAssignable。

哈希

类模板 composite_key_hash

composite_key_hash 基于初级哈希函子集合生成composite_key_result实例的哈希值。

template<typename Hash0,...,typename Hashn>
struct composite_key_hash
{
  typedef boost::tuple<Hash0,...,Hashn> key_hasher_tuple;

  composite_key_hash(
    const Hash0& h0=Hash0(),
    ...
    const Hashn& hn=Hashn());

  composite_key_hash(const key_hasher_tuple& x);

  const key_hasher_tuple& key_hash_functions()const;
  key_hasher_tuple&       key_hash_functions();

  template<typename CompositeKey>
  std::size_t operator()(
    const composite_key_result<CompositeKey>& x)const;
  
  template<typename... Values>
  std::size_t operator()(
    const std::tuple<Values...>& x)const;

  template<typename Value0,...,typename Valuen>
  std::size_t operator()(
    const boost::tuple<Value0,...,Valuen>& x)const;
};

Hash0, ... , Hashn 是composite_key_hash存储的哈希一元函数对象的类型。这些对象必须是CopyConstructible和CopyAssignable，并返回类型为std::size_t的值，该值在[0, std::numeric_limits<std::size_t>::max()))范围内。必须至少提供一个哈希函子。composite_key_hash 实例化的最大哈希函子数量由实现定义。composite_key_hash是CopyConstructible和CopyAssignable。如果每个Hashi本身都是DefaultConstructible，那么它也是DefaultConstructible。

符号

在下文中，我们使用与 composite_key_result相同的符号。

composite_key_hash 成员

效果：构造一个存储所提供的哈希函子副本的composite_key_hash。

效果：构造一个存储x中提供的哈希函子副本的composite_key_hash。

返回：对composite_key_hash内部存储的保存哈希函子的元组的常量引用。

返回：对composite_key_hash内部存储的保存哈希函子的元组的引用。

要求：length(x)==length(key_hash_functions())。表达式key_hash_functions().get<i>()(xi) 对[0,length(x))内的所有i都必须有效。
返回：[0, std::numeric_limits<std::size_t>::max())范围内的值，该值仅取决于数值元组

(key_hash_functions().get<0>()(x0), ... , key_hash_functions().get<N>()(xN))，其中N=length(x)-1。

类模板 composite_key_result_hash

已弃用。请改用boost::hash<CompositeKeyResult>。

composite_key 结果的boost::hash 特例化

boost::hash<CompositeKeyResult>，其中CompositeKeyResult是composite_key_result的实例化，其行为类似于composite_key_hash的特例，其中提供的所有哈希函子都是boost::hash的实例化。

namespace boost{

template<typename CompositeKey>
struct hash<multi_index::composite_key_result<CompositeKey> >
{
  typedef multi_index::composite_key_result<CompositeKey> argument_type;
  typedef std::size_t                                     result_type;

  template<typename CompositeKey>
  std::size_t operator()(
    const multi_index::composite_key_result<CompositeKey>& x)const;
  
  template<typename... Values>
  std::size_t operator()(
    const std::tuple<Values...>& x)const;

  template<typename Value0,...,typename Valuen>
  std::size_t operator()(
    const boost::tuple<Value0,...,Valuen>& x)const;
};

} // namespace boost

CompositeKeyResult必须是某种类型composite_key<KeyFromValue0,...,KeyFromValuen>的composite_key_result实例化。然后，boost::hash<CompositeKeyResult>::operator() 等价于composite_key_hash<Hash0,...,Hashn>::operator()，取

Hashi = boost::hash<KeyFromValuei::result_type>，对于所有i = 0,...,n。

除了composite_key_hash对Hashi的要求外，这些类型还必须是DefaultConstructible。boost::hash<CompositeKeyResult>是DefaultConstructible、CopyConstructible和CopyAssignable。

composite_key_result 的语义

composite_key_result 对象的相等性、比较和哈希运算的设计基于以下原理：composite_key_result被视为一个“虚拟”元组，其每个元素都是相应初级键提取器的结果。因此，任何给定的操作都解析为相应逐元素操作的组合。这种映射保留了所涉及初级操作的基本属性；例如，如果基本谓词本身就诱导出等价关系，则它定义了一个真正的等价关系。我们可以用正式的方式陈述这些事实。

考虑使用类型Pred0, ... , Predn的composite_key_equal_to实例化，使得每个Predi都在某种类型Ti上诱导出等价关系，并设CompositeKey为composite_key<Value,KeyFromValue0,...,KeyFromValuej>形式的类型，其中j <= n，使得

KeyFromValuei::result_type = Ti，对于所有i = 0,...,j。

tuple<Q0,...,Qj>,
composite_key_result<composite_key<K0,...,Kj> >，其中对于所有i = 0,...,j，Ki::result_type = Qi。

至于比较，考虑使用类型Compare0, ... , Comparen的composite_key_compare实例化，使得每个Comparei都在类型Ti上诱导出严格弱排序。然后，对于以与上述相同方式定义的CompositeKey类型，composite_key_compare在composite_key_result<CompositeKey>类型元素上诱导出严格弱排序，并且诱导的顺序是词典序。此外，以下类型是关于composite_key_result<CompositeKey>的composite_key_compare的兼容键

tuple<Q0,...,Qk>, k <= n
composite_key_result<composite_key<K0,...,Kk> >，其中对于所有i = 0,...,k，Ki::result_type = Qi。

• 对于i = 0,...,min(j,k)-1，Qi要么是Ti，要么不比Ti粗糙（Qi是Comparei的兼容键，并且Ti中没有两个不同的元素等价于Qi中的单个元素）；
• Qm（其中m = min(j,k)）或者是Tm，或者是一个Comparem的兼容键。

composite_key_result的相等和比较运算符具有类似的属性。但是请注意，相等运算符仅针对长度相同的对象定义，而比较运算符则考虑操作数的最小长度。因此，由x==y引起的等价类是与!(x<y)&&!(y<x)相关的等价类的子集。

头文件 "boost/multi_index/key.hpp" 概要

#include <boost/multi_index/member.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/global_fun.hpp>
#include <boost/multi_index/composite_key.hpp>

#if implementation defined /* auto non-type template parameters supported */

#define BOOST_MULTI_INDEX_KEY_SUPPORTED

namespace boost{

namespace multi_index{

template<auto... Keys>
using key=implementation defined;

} /* namespace multi_index */

} /* namespace boost */

#endif

别名模板 key

在符合 C++17 标准的环境中，key 提供了一种非常简洁的语法来指定 Boost.MultiIndex 预定义的键提取器。传递给 key 的模板参数数量必须大于零，并且不能超过composite_key 接受的最大键提取器数量。key<Key> 将解析为

• member<Class,Type,Key> 如果 Key 的类型为 Type Class::*，
• const_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()const（是否包含noexcept 说明符均可），
• cv_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()const volatile（是否包含noexcept 说明符均可），
• cref_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()const&（是否包含noexcept 说明符均可），
• cvref_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()const volatile&（是否包含noexcept 说明符均可），
• mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()（是否包含noexcept 说明符均可），
• volatile_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()volatile（是否包含noexcept 说明符均可），
• ref_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()&（是否包含noexcept 说明符均可），
• vref_mem_fun<Class,Type,Key> 如果 Key 的类型为 Type (Class::*)()volatile&（是否包含noexcept 说明符均可），
• global_fun<Value,Type,Key> 如果 Key 的类型为 Type (*)(Value)（是否包含noexcept 说明符均可），

• KeyFromValuei = key<Keyi> 对于所有 i = 0,...,n
• Value = std::decay_t<Value0> ⊗ std::decay_t<Value1> ⊗ ··· ⊗ std::decay_t<Valuen>，

随机访问索引

Boost.MultiIndex 参考

编译器特性

2020年4月19日修订

© 版权所有 2003-2020 Joaquín M López Muñoz。根据 Boost 软件许可证版本 1.0 分发。(参见随附文件 LICENSE_1_0.txt 或复制自 https://boost.ac.cn/LICENSE_1_0.txt)