Boost C++ 库

……世界上最受推崇且设计最专业的 C++ 库项目之一。 Herb SutterAndrei Alexandrescu,《C++ 编码规范

迭代器原型 - Boost C++ 函数库

迭代器原型

作者 David Abrahams, Jeremy Siek, Thomas Witt
联系方式 dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
组织 Boost Consulting, Indiana University 开放系统实验室, Zephyr Associates, Inc.
日期 2006-09-11
版权 Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004.
摘要iterator_archetype类构建了对迭代器访问概念和迭代器遍历概念之一的最小实现。它用于在编译时检查模板的类型要求是否足以覆盖模板的实现。更多信息请参阅 boost::concept_check 库的文档。

参考

iterator_archetype提要

namespace iterator_archetypes
{
    // Access categories

    typedef /*implementation  defined*/ readable_iterator_t;
    typedef /*implementation  defined*/ writable_iterator_t;
    typedef /*implementation  defined*/ readable_writable_iterator_t;
    typedef /*implementation  defined*/ readable_lvalue_iterator_t;
    typedef /*implementation  defined*/ writable_lvalue_iterator_t;

}

template <
    class Value
  , class AccessCategory
  , class TraversalCategory
>
class iterator_archetype
{
    typedef /* see below */ value_type;
    typedef /* see below */ reference;
    typedef /* see below */ pointer;
    typedef /* see below */ difference_type;
    typedef /* see below */ iterator_category;
};

访问 类别 标签

提供的访问类别类型对应于以下标准迭代器访问概念组合

readable_iterator_t :=

  Readable Iterator

writable_iterator_t :=

  Writeable Iterator

readable_writable_iterator_t :=

  Readable Iterator & Writeable Iterator & Swappable Iterator

readable_lvalue_iterator_t :=

  Readable Iterator & Lvalue Iterator

writeable_lvalue_iterator_t :=

  Readable Iterator & Writeable Iterator & Swappable Iterator & Lvalue Iterator

iterator_archetype要求

AccessCategory参数必须是预定义的访问类别标签之一。TraversalCategory必须是标准遍历标签之一。类型必须满足由以下指定的迭代器概念的要求AccessCategoryandTraversalCategory如嵌套特性类型所暗示的那样。

iterator_archetype模型

iterator_archetype实现了由以下指定的迭代器概念AccessCategoryandTraversalCategory参数。iterator_archetype不实现任何其他访问概念或更高级的遍历概念。

特性

嵌套特性类型定义如下:

if (AccessCategory == readable_iterator_t)

  value_type = Value
  reference  = Value
  pointer    = Value*

else if (AccessCategory == writable_iterator_t)

  value_type = void
  reference  = void
  pointer    = void

else if (AccessCategory == readable_writable_iterator_t)

  value_type = Value

  reference :=

    A type X that is convertible to Value for which the following
    expression is valid. Given an object x of type X and v of type
    Value.

    x = v

  pointer    = Value*

else if (AccessCategory == readable_lvalue_iterator_t)

  value_type = Value
  reference  = Value const&
  pointer    = Value const*

else if (AccessCategory == writable_lvalue_iterator_t)

  value_type = Value
  reference  = Value&
  pointer    = Value*

if ( TraversalCategory is convertible to forward_traversal_tag )

  difference_type := ptrdiff_t

else

  difference_type := unspecified type


iterator_category :=

  A type X satisfying the following two constraints:

     1. X is convertible to X1, and not to any more-derived
        type, where X1 is defined by:

          if (reference is a reference type
              && TraversalCategory is convertible to forward_traversal_tag)
          {
              if (TraversalCategory is convertible to random_access_traversal_tag)
                  X1 = random_access_iterator_tag
              else if (TraversalCategory is convertible to bidirectional_traversal_tag)
                  X1 = bidirectional_iterator_tag
              else
                  X1 = forward_iterator_tag
          }
          else
          {
              if (TraversalCategory is convertible to single_pass_traversal_tag
                  && reference != void)
                  X1 = input_iterator_tag
              else
                  X1 = output_iterator_tag
          }

     2. X is convertible to TraversalCategory