Code for a basic random access iterator based on pointers?
c++, iterator, stl
Solution
In general your approach is right. The postfix increment/decrement operator should return by value, not by reference. I also have doubts about:
Iterator(Type* rhs) : _ptr(rhs) {;}
This tells everyone that this iterator class is implemented around pointers. I would try making this method only callable by the container. Same for assignment to a pointer. Adding two iterators makes no sense to me (I would leave "iterator+int"). Substracting two iterators pointing to the same container might make some sense.
Problem
I've never implemented STL-like iterators and I try to understand how to implement a very basic thing based on pointers. Once I will have this class I will be able to modify it to do more complicated things. Consequently, this is a first step, and I need it to be rock solid to understand how to write my own iterators (without boost). I have written the following code and I know that there are errors in it. Can you help me to design correctly a Random Access Iterator class inspired from that : ``` template<Type> class Container<Type>::Iterator : public std::iterator<random_access_iterator_tag, Type> { // Lifecycle: public: Iterator() : _ptr(nullptr) {;} Iterator(Type* rhs) : _ptr(rhs) {;} Iterator(const Iterator &rhs) : _ptr(rhs._ptr) {;} // Operators : misc public: inline Iterator& operator=(Type* rhs) {_ptr = rhs; return *this;} inline Iterator& operator=(const Iterator &rhs) {_ptr = rhs._ptr; return *this;} inline Iterator& operator+=(const int& rhs) {_ptr += rhs; return *this;} inline Iterator& operator-=(const int& rhs) {_ptr -= rhs; return *this;} inline Type& operator*() {return *_ptr;} inline Type* operator->() {return _ptr;} inline Type& operator[](const int& rhs) {return _ptr[rhs];} // Operators : arithmetic public: inline Iterator& operator++() {++_ptr; return *this;} inline Iterator& operator--() {--_ptr; return *this;} inline Iterator& operator++(int) {Iterator tmp(*this); ++_ptr; return tmp;} inline Iterator& operator--(int) {Iterator tmp(*this); --_ptr; return tmp;} inline Iterator operator+(const Iterator& rhs) {return Iterator(_ptr+rhs.ptr);} inline Iterator operator-(const Iterator& rhs) {return Iterator(_ptr-rhs.ptr);} inline Iterator operator+(const int& rhs) {return Iterator(_ptr+rhs);} inline Iterator operator-(const int& rhs) {return Iterator(_ptr-rhs);} friend inline Iterator operator+(const int& lhs, const Iterator& rhs) {return Iterator(lhs+_ptr);} friend inline Iterator operator-(const int& lhs, const Iterator& rhs) {return Iterator(lhs-_ptr);} // Operators : comparison public: inline bool operator==(const Iterator& rhs) {return _ptr == rhs._ptr;} inline bool operator!=(const Iterator& rhs) {return _ptr != rhs._ptr;} inline bool operator>(const Iterator& rhs) {return _ptr > rhs._ptr;} inline bool operator<(const Iterator& rhs) {return _ptr < rhs._ptr;} inline bool operator>=(const Iterator& rhs) {return _ptr >= rhs._ptr;} inline bool operator<=(const Iterator& rhs) {return _ptr <= rhs._ptr;} // Data members protected: Type* _ptr; }; ``` Thank you very much.