Why do I need to define these in std for my random access iterator???

Question

Hi guys,
I have written my own iterator class, to support 1-d slices of 2-d matrices, 2-d slices of 3-d matrices, etc.
At first I wrote the class as a bidirectional iterator, but then I needed to extend it to random access so that I could pass these iterators to std::sort etc. No problem, I thought, I just needed to add friend operators for "iterator-iterator" and "iterator+/-distance".
So, I did that and tested the code with VS6 and various versions of g++, with no problems. Isn't STL great!
But I had endless problems with Studio 10. It kept griping that various mostly-internal-looking template functions were not defined. The only way I could get it to work was to define these:
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x570)
namespace std
     template<typename T>          // Sigh
     typename matrixit<T>::
     difference_type distance(const matrixit<T>& a, const matrixit<T>& b) {
          return b-a;
     template<typename T>           // WTF?
     T* __value_type(const matrixit<T>&) {
          return static_cast<T*>(0);
     template<typename T>           // WTF?
     typename matrixit<T>::
     difference_type* __distance_type(const matrixit<T>&) {
          return static_cast<typename matrixit<T>::difference_type*>(0);
     template<typename T>           // WTF?
     typename matrixit<T>::
     iterator_category __iterator_category(const matrixit<T>&) {
          return typename matrixit<T>::iterator_category();
#endif
Why do I have to do this, or am I missing something in my iterator class (eg, typedefs), or do I need to derive it from something? Here is what it looks like:
template<typename T>
class matrixit
public:
     typedef T&                         reference;
     typedef T*                         pointer;
     typedef T                         value_type;
     typedef size_t                    size_type;
     typedef ptrdiff_t               difference_type;
     typedef std::random_access_iterator_tag iterator_category;
Ta, Simon.

Answer 1

Come on, it is not that hard to work around the limitations of Cstd. For what you show here, you can use:
namespace std {
template <class Iterator> struct iterator_traits
typedef typename Iterator::value_type value_type;
typedef typename Iterator::difference_type difference_type;
typedef typename Iterator::pointer pointer;
typedef typename Iterator::reference reference;
typedef typename Iterator::iterator_category iterator_category;
template <class T> struct iterator_traits<T*>
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
typedef random_access_iterator_tag iterator_category;
template <class T> struct iterator_traits<const T*>
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef const T* pointer;
typedef const T& reference;
typedef random_access_iterator_tag iterator_category;
template <class ForwardIterator>
inline ptrdiff_t
distance (ForwardIterator first, ForwardIterator last)
ptrdiff_t n = 0;
__distance(first, last, n,
iterator_traits<ForwardIterator>::iterator_category());
return n;
template <class InputIterator, class T>
inline typename iterator_traits<InputIterator>::difference_type
count (InputIterator first, InputIterator last, const T& value)
typename iterator_traits<InputIterator>::difference_type result;
count(first,last,value,result);
return result;
template <class InputIterator, class Predicate>
inline typename iterator_traits<InputIterator>::difference_type
count_if (InputIterator first, InputIterator last, Predicate pred)
typename iterator_traits<InputIterator>::difference_type result;
count_if(first,last,pred,result);
return result;
template < class T >
inline typename T::value_type*
__value_type (const T&)
{ return (typename T::value_type*)(0); }
template < class T >
inline typename T::difference_type*
__distance_type(const T&)
{ return (typename T::difference_type*)(0); }
template < class T >
inline typename T::iterator_category
__iterator_category (const T&)
typename T::iterator_category tmp;
return tmp;
} // namespace std
For the missing constructor of vector with iterators, you can simply use std::copy with a back_insert_iterator.
The hardest thing to work around is probably the missing conversion between std::pair of various types (for instance with various constness when you use std::map), but it can still be handled by always specifying the type of the pair instead of relying on std::make_pair.
And if there is a thing you really don't know how to work around, you can always ask here...