boost 如何将类型列表实现为类的"options"？

How does boost implement lists of types as "options" for classes?

本文关键字：options 实现 类型 列表 boost      更新时间：2023-10-16

不使用示例来表达这个问题有点困难，所以我会直截了当。

作为一个基本的例子，boost::intrusive::list有一些有趣的模板，我很难弄清楚它们是如何工作的。类规范看起来有点像这样：

template<typename T, class... Options> 
class list {
   ...
};

我的重点是Options参数。对于初学者来说，它是可变的。这在 c++11 中是"微不足道的"，因为它得到了语言的支持。而且在 c++03 中模拟当然很容易（最多可以有 10 个参数，所有参数都有一些默认的令牌值）。

这是我的问题：

Options可以按任何顺序采用任意数量的"选项"类型。例如：

typedef list<Foo, constant_time_size<false> > FooList;

或

//This option will configure "list" to use the member hook
typedef member_hook<Foo, list_member_hook<>, &Foo::hook_> MemberHookOption;
//This list will use the member hook
typedef list<Foo, MemberHookOption> FooList;

这真的很酷...他们到底是如何为所有不同的组合做到这一点的。如果我两次传递相同类型的选项会怎样？对于boost::instrusive::list，可能的选项是：

  • base_hook<class Hook> / member_hook<class T, class Hook, Hook T::* PtrToMember> / value_traits<class ValueTraits> ：所有这些选项都指定了要插入列表中的T型和钩子之间的关系（因为我们可以在同一T类型中有多个钩子）。 稍后将member_hook解释，value_traits将在具有自定义 ValueTraits 的容器部分中进行解释。如果未指定任何选项，则将容器配置为使用带有默认标记的基挂钩。为挂钩配置的一些选项（指针类型、链接模式等）将传播到容器。

  • constant_time_size<bool Enabled> ：指定容器是否需要常量 time size（） 函数。这将指示侵入容器存储其他成员以跟踪容器的当前大小。默认情况下，将激活恒定时间大小。

  • size_type<bool Enabled> ：指定可以容纳容器大小的类型。此类型将是 list.size（） 返回的类型，如果请求constant_time_size，则为存储在侵入性容器中的类型。用户通常不需要更改此类型，但某些容器的size_type可能与 std：：size_t 不同（例如，类似 STL 的容器使用其分配器定义的size_type）。Boost.Intrusive 可用于实现指定大小类型的此类容器。默认情况下，类型为 std：：size_t。

我喜欢这个概念，因为它允许编译类型行为的定义。但正如您可以想象的那样，各种组合可能会变得复杂。我猜通过一些魔术，他们将选项规范化为可用于真实数据结构的简单结构。但这只是猜测工作：-P

在尝试策略库设计时，我已经这样做了几次。

我使用的核心思想是标记策略（通过内部 typedef，类似于迭代器的iterator_category），然后我定义了一个类，该类将简单地遍历列表并为类别提取给定的策略，如果两个策略引用同一类别，则引发编译错误。像这样：

template <typename Tag, typename Opt, typename... Options>
struct CategoryExtractorImpl {
  typedef typename if_<
            same_type<typename Opt::Tag, Tag>,
            Opt,
            void
  >::type Lhs;
  typedef typename CategoryExtractorImpl<Tag, Options...>::type Rhs;
  typedef typename Combinator<Lhs,Rhs>::type type;
};

其中if_只是根据谓词在两种类型之间进行选择，组合器写成：

template <typename, typename> struct Combinator;
template <typename L> struct Combinator<L, void> { typedef L type; };
template <typename R> struct Combinator<void, R> { typedef R type; };
template <> struct Combinator<void, void> { typedef void type; };

当然，您还需要提供默认值，以防根本没有提供策略。

template <typename L, typename R> struct ForgivingCombinator { typedef L type; };
template <typename R> struct ForgivingCombinator<void, R> { typedef R type; };

最后，你会得到：

template <typename Default, typename... Options>
struct CategoryExtractor {
  typedef typename ForgivingCombinator<
      typename CategoryExtactorImpl<typename Default::Tag, Options...>::type
      Default
  >::type type;
};

使用它，您只需轻松提取所有类别：

template <typename... Options>
class List {
  typedef typename CategoryExtractor<DefaultPolicyX, Options...>::type PolicyX;
  typedef typename CategoryExtractor<DefaultPolicyY, Options...>::type PolicyY;
  ...
};
当然，在

典型的基于策略的设计中，它可能会变得更加冗长，因为您将私下从它们继承（以触发 EBO），然后在需要时在类中重复实际类型。

相关文章：