# std::iterator

From cppreference.com
< cpp‎ | iterator

Defined in header `<iterator>` |  |
template< class Category, class T, class Distance = std::ptrdiff_t, class Pointer = T*, class Reference = T& > struct iterator; |  | (deprecated in C++17)

`std::iterator` is the base class provided to simplify definitions of the required types for iterators.

### Template parameters

Category | - | the category of the iterator. Must be one of iterator category tags.
T | - | the type of the values that can be obtained by dereferencing the iterator. This type should be `void` for output iterators.
Distance | - | a type that can be used to identify distance between iterators
Pointer | - | defines a pointer to the type iterated over (`T`)
Reference | - | defines a reference to the type iterated over (`T`)

### Member types

Member type | Definition
`iterator_category` | `Category`
`value_type` | `T`
`difference_type` | `Distance`
`pointer` | `Pointer`
`reference` | `Reference`

### Example

The following example shows how to implement a input iterator by inheriting from std::iterator

Run this code

    #include <iostream>
    #include <algorithm>

    template<long FROM, long TO>
    class Range {
    public:
        // member typedefs provided through inheriting from std::iterator
        class iterator: public std::iterator<
                            std::input_iterator_tag,   // iterator_category
                            long,                      // value_type
                            long,                      // difference_type
                            const long*,               // pointer
                            long                       // reference
                                          >{
            long num = FROM;
        public:
            explicit iterator(long _num = 0) : num(_num) {}
            iterator& operator++() {num = TO >= FROM ? num + 1: num - 1; return *this;}
            iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
            bool operator==(iterator other) const {return num == other.num;}
            bool operator!=(iterator other) const {return !(*this == other);}
            reference operator*() const {return num;}
        };
        iterator begin() {return iterator(FROM);}
        iterator end() {return iterator(TO >= FROM? TO+1 : TO-1);}
    };

    int main() {
        // std::find requires an input iterator
        auto range = Range<15, 25>();
        auto itr = std::find(range.begin(), range.end(), 18);
        std::cout << *itr << '\n'; // 18

        // Range::iterator also satisfies range-based for requirements
        for(long l : Range<3, 5>()) {
            std::cout << l << ' '; // 3 4 5
        }
        std::cout << '\n';
    }

Output:

    18
    3 4 5

### See also

iterator_traits | provides uniform interface to the properties of an iterator (class template)
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag contiguous_iterator_tag (C++20) | empty class types used to indicate iterator categories (class)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/iterator&oldid=108739"