iter-issue-list.rst

boost库提供标准的C++ API 配合dev c++使用,功能更加强大

          cat = iterator_traits<Iterator>::iterator_category;
          if (cat == iterator_tag<Access,Traversal>)
              return Traversal;
          else if (cat is convertible to random_access_iterator_tag)
              return random_access_traversal_tag;
          else if (cat is convertible to bidirectional_iterator_tag)
              return bidirectional_traversal_tag;
          else if (cat is convertible to forward_iterator_tag)
              return forward_traversal_tag;
          else if (cat is convertible to input_iterator_tag)
              return single_pass_iterator_tag;
          else if (cat is convertible to output_iterator_tag)
              return incrementable_iterator_tag;
          else
              return null_category_tag;


    The following specializations provide the access and traversal
    category tags for pointer types.

    ::

      template <typename T>
      struct is_readable<const T*> { typedef true_type type; };
      template <typename T>
      struct is_writable<const T*> { typedef false_type type; };
      template <typename T>
      struct is_swappable<const T*> { typedef false_type type; };

      template <typename T>
      struct is_readable<T*> { typedef true_type type; };
      template <typename T>
      struct is_writable<T*> { typedef true_type type; };
      template <typename T>
      struct is_swappable<T*> { typedef true_type type; };

      template <typename T>
      struct traversal_category<T*>
      {
        typedef random_access_traversal_tag type;
      };

  to:

    The ``is_readable_iterator`` class template satisfies the
    UnaryTypeTrait requirements.

    Given an iterator type ``X``,
    ``is_readable_iterator<X>::value`` yields ``true`` if, for an
    object ``a`` of type ``X``, ``*a`` is convertible to
    ``iterator_traits<X>::value_type``, and ``false`` otherwise.

    .. _`category-to-traversal`: 

    ``iterator_traversal<X>::type`` is 

    .. parsed-literal::

      *category-to-traversal*\ (iterator_traits<X>::iterator_category) 

    where *category-to-traversal* is defined as follows

    .. parsed-literal::

       *category-to-traversal*\ (C) =
           if (C is convertible to incrementable_traversal_tag)
               return C;
           else if (C is convertible to random_access_iterator_tag)
               return random_access_traversal_tag;
           else if (C is convertible to bidirectional_iterator_tag)
               return bidirectional_traversal_tag;
           else if (C is convertible to forward_iterator_tag)
               return forward_traversal_tag;
           else if (C is convertible to input_iterator_tag)
               return single_pass_traversal_tag;
           else if (C is convertible to output_iterator_tag)
               return incrementable_traversal_tag;
           else
               *the program is ill-formed*

  In N1530:

  In [lib.iterator.helper.synopsis]:

  Change::

    const unsigned use_default_access = -1;

    struct iterator_core_access { /* implementation detail */ };

    template <
        class Derived
      , class Value
      , unsigned AccessCategory
      , class TraversalCategory
      , class Reference  = Value&
      , class Difference = ptrdiff_t
    >
    class iterator_facade;

    template <
        class Derived
      , class Base
      , class Value      = use_default
      , unsigned Access  = use_default_access
      , class Traversal  = use_default
      , class Reference  = use_default
      , class Difference = use_default
    >
    class iterator_adaptor;

    template <
        class Iterator
      , class Value = use_default
      , unsigned Access  = use_default_access
      , class Traversal  = use_default
      , class Reference = use_default
      , class Difference = use_default
    >
    class indirect_iterator;

  To::

    struct iterator_core_access { /* implementation detail */ };

    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference  = Value&
      , class Difference = ptrdiff_t
    >
    class iterator_facade;

    template <
        class Derived
      , class Base
      , class Value      = use_default
      , class CategoryOrTraversal  = use_default
      , class Reference  = use_default
      , class Difference = use_default
    >
    class iterator_adaptor;

    template <
        class Iterator
      , class Value = use_default
      , class CategoryOrTraversal = use_default
      , class Reference = use_default
      , class Difference = use_default
    >
    class indirect_iterator;
    
  Change::

    template <
        class Incrementable
      , unsigned Access  = use_default_access
      , class Traversal  = use_default
      , class Difference = use_default
    >
    class counting_iterator

  To::

    template <
        class Incrementable
      , class CategoryOrTraversal  = use_default
      , class Difference = use_default
    >
    class counting_iterator;

  In [lib.iterator.facade]:

  Change::

    template <
        class Derived
      , class Value
      , unsigned AccessCategory
      , class TraversalCategory
      , class Reference  = /* see below */
      , class Difference = ptrdiff_t
    >
    class iterator_facade {

  to::

    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference  = Value&
      , class Difference = ptrdiff_t
    >
    class iterator_facade {


  Change::

        typedef iterator_tag<AccessCategory, TraversalCategory> iterator_category;
  
  to::

        typedef /* see below */ iterator_category;


  Change::
  
    // Comparison operators
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type // exposition
    operator ==(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
                iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator !=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
                iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator <(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
               iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator <=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
                iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator >(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
               iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator >=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
                iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator >=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
                iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    // Iterator difference
    template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
              class Dr2, class V2, class AC2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1, Dr2, bool>::type
    operator -(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
               iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
  
    // Iterator addition
    template <class Derived, class V, class AC, class TC, class R, class D>
    Derived operator+ (iterator_facade<Derived, V, AC, TC, R, D> const&,
                       typename Derived::difference_type n)

  to::

    // Comparison operators
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
    operator ==(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
                iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type
    operator !=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
                iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type
    operator <(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type
    operator <=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
                iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type
    operator >(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    typename enable_if_interoperable<Dr1,Dr2,bool>::type
    operator >=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
                iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    // Iterator difference
    template <class Dr1, class V1, class TC1, class R1, class D1,
              class Dr2, class V2, class TC2, class R2, class D2>
    /* see below */
    operator-(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
  
    // Iterator addition
    template <class Dr, class V, class TC, class R, class D>
    Derived operator+ (iterator_facade<Dr,V,TC,R,D> const&,
                       typename Derived::difference_type n);
  
    template <class Dr, class V, class TC, class R, class D>
    Derived operator+ (typename Derived::difference_type n,
                       iterator_facade<Dr,V,TC,R,D> const&);


  After the ``iterator_facade`` synopsis, add:

  The ``iterator_category`` member of ``iterator_facade`` is

  .. parsed-literal::

    *iterator-category*\ (CategoryOrTraversal, value_type, reference)

  where *iterator-category* is defined as follows:

  .. parsed-literal::
      
      *iterator-category*\ (C,R,V) :=
         if (C is convertible to std::input_iterator_tag
             || C is convertible to std::output_iterator_tag
         )
             return C
    
         else if (C is not convertible to incrementable_traversal_tag)
             *the program is ill-formed*
    
         else return 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 (R is a reference type
                     && C is convertible to forward_traversal_tag)
                 {
                     if (C is convertible to random_access_traversal_tag)