Proposed resolution:

This wording is relative to N4659.

1. Change [iterator.synopsis] as indicated:

   // [iterator.primitives], primitives
   template<class Iterator> struct iterator_traits;
   template<class T> struct iterator_traits<T*>;
   template<class T> struct iterator_traits<const T*>;
   

2. Change [iterator.traits] as indicated:

   -3- It is specialized for pointers as

   namespace std {
     template<class T> struct iterator_traits<T*> {
       using difference_type = ptrdiff_t;
       using value_type = remove_cv_t<T>;
       using pointer = T*;
       using reference = T&;
       using iterator_category = random_access_iterator_tag;
     };
   }
   

   and for pointers to const as

   namespace std {
     template<class T> struct iterator_traits<const T*> {
       using difference_type = ptrdiff_t;
       using value_type = T;
       using pointer = const T*;
       using reference = const T&;
       using iterator_category = random_access_iterator_tag;
     };
   }
   

[ 2017-07 Toronto Wed Issue Prioritization ]

Priority 0; move to Ready

[ 2017-03-30, David Krauss comments ]

volatile pointers may not be well-behaved random-access iterators. When simple access incurs side effects, the multiple-pass guarantee depends on underlying (hardware) semantics.

iterator_traits accepts pointer to volatile T*, but then says that the value_type is volatile T, instead of T, which is inconsistent for what it does for pointer to const T. We should either reject volatile outright or give the right answer.