пользовательская реализация итератора, вызывающая утечки памяти

Question

Я реализовал random_access_iterator для пользовательской библиотеки (которая была задумана для повторного использования как для итератора констант, так и для неконстантного итератора), но это вызывает утечку памяти, делая что-то вроде std::sort(container.begin(), container.end() (container.begin()/end() return iterator экземпляр.

Что случилось с моей реализации?

template <bool is_const_iterator = false> 
class meta_iterator : public std::iterator<std::random_access_iterator_tag, T> { 
public: 
    typedef T value_type; 
    typedef std::ptrdiff_t difference_type; 
    typedef typename std::conditional<is_const_iterator, const value_type &, 
            value_type &> reference; 
    typedef std::random_access_iterator_tag iterator_category; 
    typedef typename std::conditional<is_const_iterator, value_type const *, 
            value_type *>::type pointer; 
    typedef meta_iterator self_type; 

    meta_iterator(T *ptr) : ptr_(ptr) {} 

    meta_iterator(const meta_iterator<true> &other) : ptr_(other.ptr_) {} 

    self_type operator+(difference_type value) { 
    ptr_ += value; 
    return *(this); 
    }; 

    self_type operator-(difference_type value) { 
    ptr_ -= value; 
    return *(this); 
    }; 

    difference_type operator-(const self_type &other) { 
    return ptr_ - other.ptr_; 
    } 

    T &operator[](difference_type value) const { return *ptr_[value]; } 
    bool operator==(const self_type &other) const { return ptr_ == other.ptr_; } 
    bool operator!=(const self_type &other) const { return !(*this == other); } 
    bool operator>=(const self_type &other) const { return !((*this) < other); } 
    bool operator<=(const self_type &other) const { return !((*this) > other); } 
    bool operator<(const self_type &other) const { return ptr_ < other.ptr_; } 
    bool operator>(const self_type &other) const { return ptr_ < other.ptr_; } 
    self_type &operator=(const self_type &other) { 
    ptr_ = other.ptr_; 
    return *(this); 
    } 
    T *operator->() const { return ptr_; } 
    T &operator*() const { return *ptr_; } 

    self_type &operator--() { 
    ptr_--; 
    return *this; 
    } 

    self_type operator--(int) { 
    self_type temp(*this); 
    --(*this); 
    return (temp); 
    } 

    self_type &operator++() { 
    ptr_++; 
    return *this; 
    } 

    self_type operator++(int) { 
    self_type temp(*this); 
    --(*this); 
    return (temp); 
    } 

    self_type &operator+=(difference_type value) { 
    ptr_ += value; 
    return *(this); 
    } 

    self_type &operator-=(difference_type value) { 
    ptr_ -= value; 
    return *(this); 
    } 

    friend class meta_iterator<true>; 
    friend class meta_iterator<false>; 

private: 
    T *ptr_; 
}; 

Answer 1

не знаю, если это вызывает утечку памяти, но эти два оператора

self_type operator+(difference_type value) { 
    ptr_ += value; 
    return *(this); 
    }; 

    self_type operator-(difference_type value) { 
    ptr_ -= value; 
    return *(this); 
    }; 

должен просто вернуть новый итератор и не обновлять сохраненные ptr_.

Кроме того, есть опечатка в

self_type operator++(int) { 
    self_type temp(*this); 
    --(*this); 
    return (temp); 
    } 

делает его идти в неправильном направлении. Вероятно, это путает некоторые петли.