How do you create and use a custom iterator in C++ with an example? — C++ Interview Question #43

In C++, an iterator is an object that allows you to traverse the elements of a container. The standard library provides several iterator types for its container classes, such as vector, list, and map. However, it is also possible to define your own custom iterator to traverse your own data structures.

To create a custom iterator, you need to define a class that implements a set of standard iterator methods. These methods include:

operator++() to advance the iterator to the next element
operator*() to return the value of the current element
operator==() and operator!=() to compare two iterators
operator->() to access the members of the current element (optional)

Here is an example of a simple custom iterator that allows you to traverse the elements of a vector<int> object in reverse order:

    #include <vector>
    
    class ReverseIterator {
        public:
        ReverseIterator(std::vector<int>::iterator iter) : m_iter(iter) {}
        
        ReverseIterator& operator++() {
            --m_iter;
            return *this;
        }
        
        int& operator*() {
            return *m_iter;
        }
        
        bool operator==(const ReverseIterator& other) const {
            return m_iter == other.m_iter;
        }
        
        bool operator!=(const ReverseIterator& other) const {
            return !(*this == other);
        }
        
        private:
        std::vector<int>::iterator m_iter;
    };
    
    int main() {
        std::vector<int> myVector = {1, 2, 3, 4, 5};
        
        // Traverse the vector in reverse order
        for (ReverseIterator it = myVector.end() - 1; it != myVector.begin() - 1; ++it) {
            std::cout << *it << " ";
        }
        std::cout << std::endl;
        
        return 0;
    }

In this example, we have defined a custom iterator class called ReverseIterator that takes a standard vector<int>::iterator as its constructor argument. The operator++() method is defined to decrement the iterator to traverse the elements in reverse order, and the operator*() method is defined to return a reference to the current element. The operator==() and operator!=() methods are defined to compare two iterators based on their underlying iterators.

We can use this custom iterator to traverse a vector<int> object in reverse order, as shown in the main() function. We create a ReverseIterator object that starts at the end of the vector, and then traverse the vector using a for loop until we reach the beginning of the vector.

Note that this is just a simple example, and in practice, creating a custom iterator can be more complex depending on the data structure and the desired traversal order. However, the basic principles remain the same: define a class that implements the required iterator methods, and use it to traverse the elements of the data structure.