Собственный класс итератора - C++ - Ответ 4729130

/// Представляет поэлементный доступ к элементам коллекции
/// @param T - тип элементов коллекции
template<typename T>
class Iterator {
public:
    typedef T* pointer;          //!< Указатель на значение
    typedef T reference;         //!< Ccылка на значение
    typedef T value_type;        //!< Предопределенный тип для T
    typedef matx::size_t dist_t; //!< Тип для представления расстояния между итераторами
 
    Iterator();        //!< Конструктор по умолчанию
    Iterator(pointer); //!< Конструктор с параметром
    Iterator(const Iterator&); //!< Конструктор копий
 
    Iterator& operator = (const Iterator &);        //!< Оператор присваивания
 
    bool      operator == (const Iterator &) const; //!< Оператор сравнения
    bool      operator != (const Iterator &) const; //!< Оператор не-сравнения
 
    reference operator *  () const; //!< Разыменование итератора
    pointer   operator -> () const; //!< Косвенное обращение
    /// @bug only prefix
    Iterator& operator ++ ();    //!< prefix-incerment
    //Iterator& operator ++ (int); //!< postfix-incerment
    Iterator& operator -- ();    //!< prefix-decerment
    //Iterator& operator -- (int); //!< postfix-decerment
 
    Iterator  operator +  (const dist_t) const; //!< Плюс число
    Iterator  operator -  (const dist_t) const; //!< Минус число
    dist_t    operator -  (const Iterator&) const; //!< Расстояние до другого указателя
 
    bool      operator <  (const Iterator&) const; //!< bool, если этот указатель имеет адрес меньше чем второй
    bool      operator <= (const Iterator&) const; //!< bool, если этот указатель имеет адрес меньше чем второй, или они равны
    bool      operator >  (const Iterator&) const; //!< bool, если этот указатель имеет адрес больше чем второй
    bool      operator >= (const Iterator&) const; //!< bool, если этот указатель имеет адрес больше чем второй, или они равны
 
    Iterator& operator += (const dist_t); //!< Увеличить адрес текущего вектора
    Iterator& operator -= (const dist_t); //!< Уменьшить адрес текущего вектора
 
    reference operator [] (const dist_t) const; //!< Поэлементный доступ
protected:
    pointer ptr;       //!< C-like указатель
};
 
template<typename T>
Iterator<T>::Iterator() {
    ptr = 0;
}
 
template<typename T>
Iterator<T>::Iterator(pointer ptrToElement) {
    ptr = ptrToElement;
}
 
template<typename T>
Iterator<T>::Iterator(const Iterator<T> &it) {
    ptr = it.ptr;
}
 
template<typename T>
Iterator<T>& Iterator<T>::operator = (const Iterator<T> &it) {
    ptr = it.ptr;
    return *this;
}
 
template<typename T>
bool Iterator<T>::operator == (const Iterator<T> &it) const {
    return (ptr == it.ptr);
}
 
template<typename T>
bool Iterator<T>::operator != (const Iterator<T> &it) const {
    return not(ptr == it.ptr);
}
 
template<typename T>
typename Iterator<T>::reference Iterator<T>::operator * () const {
    return *ptr;
}
 
template<typename T>
typename Iterator<T>::pointer Iterator<T>::operator -> () const {
    return &*ptr;
}
 
template<typename T>
Iterator<T>& Iterator<T>::operator ++ () {
    Iterator tmp(*this);
    ptr++;
    return *this;
}
 
//template<typename T>
//Iterator<T>& Iterator<T>::operator ++ (int) {
//  ptr++;
//  return *this;
//}
 
template<typename T>
Iterator<T>& Iterator<T>::operator -- () {
    ptr--;
    return *this;
}
 
//template<typename T>
//Iterator<T>& Iterator<T>::operator -- (int) {
//  ptr--;
//  return *this;
//}
 
template<typename T>
Iterator<T> Iterator<T>::operator + (const dist_t n) const {
    return Iterator<T>(ptr + n);
}
 
template<typename T>
Iterator<T> Iterator<T>::operator - (const dist_t n) const {
    return Iterator<T>(ptr - n);
}
 
template<typename T>
typename Iterator<T>::dist_t Iterator<T>::operator - (const Iterator<T> &it) const {
    return ptr - it.ptr;
}
 
template<typename T>
bool Iterator<T>::operator < (const Iterator<T> &it) const {
    return (ptr < it.ptr);
}
 
template<typename T>
bool Iterator<T>::operator <= (const Iterator<T> &it) const {
    return (ptr < it.ptr) or (ptr == it.ptr);
}
 
 
template<typename T>
bool Iterator<T>::operator > (const Iterator<T> &it) const {
    return (ptr > it.ptr);
}
 
template<typename T>
bool Iterator<T>::operator >= (const Iterator<T> &it) const {
    return (ptr > it.ptr) or (ptr == it.ptr);
}
 
template<typename T>
Iterator<T>& Iterator<T>::operator += (const dist_t n) {
    ptr += n;
    return *this;
}
 
template<typename T>
Iterator<T>& Iterator<T>::operator -= (const dist_t n) {
    ptr -= n;
    return *this;
}
 
template<typename T>
typename Iterator<T>::reference Iterator<T>::operator [] (const dist_t index) const {
    return *(ptr + index);
}