En ce qui concerne les déclarations des opérateurs et fonctions membres, nous devons définir les opérateurs suivants :

reference operator*(); 	// retourne la valeur à laquelle l'itérateur fait référence.
pointer operator->();           // retourne un pointeur sur la valeur à laquelle l'itérateur fait référence.
iterator& operator++();         // avance à la valeur suivante de la séquence et retourne l'itérateur courant
iterator operator++(int);       // copie l'itérateur à la position actuelle, avance l'itérateur courant 
                                // à la valeur suivante de la séquence et retourne la copie de l'itérateur.
 
bool operator ==(iterator) const;
                                // compare si l'itérateur courant et l'itérateur passé en argument 
                                // font référence à la même valeur,
bool operator !=(iterator, iterator) const;
                                // compare si l'itérateur courant et l'itérateur passé en argument 
                                // ne font pas référence à la même valeur,
 

En ce qui concerne l'opérateur *, il s'agit de l'opération de déréférencement qui va retourner une référence sur la valeur à laquelle l'itérateur fait référence et qui est défini par mCurrent. Le code de cette fonction s'écrit :

    reference operator*() const 
    {
        return mCurrent;
    }

Par similitude l'opérateur → qui retourne un pointeur sur la valeur référencée par l'itérateur va retourner un pointeur sur le champ interne mCurrent.

    reference operator->() const 
    {
        return &mCurrent;
    }

Il faut désormais implanter les opérateurs d'incrémentation de l'itérateur (ie. pour passer à la valeur suivante). C'est l'opérateur ++ qui a est sélectionné, cependant cet opérateur possède deux syntaxes : (1) ++it qui signifie applique l'opération ++ à l'objet it et retourne une référence à cet objet après que l'opération ++ a été effectuée; (2) it++ qui signifie fait une copie de l'objet copy, applique l'opération à l'objet it et retourne l'objet copy comme résultat de l'opération. L'opérateur operator ++() correspond à la première synataxe, l'opérateur operator ++(int) correspond à la seconde syntaxe. Ce qui se traduit par :

    iterator& operator++()
    {
        // Passe à la valeur suivant si nous ne sommes pas
        // déjà à la fin de l'interval.
        if(mCurrent <= mInterval->maxValue)
            mCurrent ++;
        return *this;
    }
    iterator operator++(int)
    {
        interval_iterator it(*this); // Crée une copie de l'itérateur.
        ++(*this);          // Incrément l'itérateur courant en appellant
                            // l'opérateur iterator& operator()
        return it;          // Retourne la copie de l'itérateur (avant modification).
    }

Il ne reste plus qu'à implanter les opérateurs relatifs à la comparaison. Deux itérateurs sont égaux s'ils font références à la même valeur située dans le même containeur. Dans ce cas, nous devons avoir les champs mCurrent et mInterval qui doivent être égaux.

    bool operator ==(const interval_iterator& anotherIterator) const
    {
        return mCurrent == anotherIterator.mCurrent && 
          *mInterval == *anotherIterator.mInterval;
    }
    bool operator !=(const interval_iterator& anotherIterator) const
    {
        return mCurrent != anotherIterator.mCurrent || 
          *mInterval != *anotherIterator.mInterval;
    }

Enfin, l'itérateur doit aussi être constructible par recopie, supporter l'affection et supporter les permutations), ce qui impose de définir en complément le constructeur de recopie, les fonctions membres swap et l'opérateur = comme suit:

public:
    // Définition du constructeur de recopie.
    // Crée un itérateur qui fait référence au même élément que l'itérateur
    // passé en argument.
    interval_iterator(const interval_iterator& anotherIterator):
        mCurrent(anotherIterator.mCurrent), mInterval(anotherIterator.mInterval)
    {}
    // Définition de l'opération d'affectation consistant à ce que 
    // l'itérateur courant fait référence au même élément que l'itérateur
    // passé en argument.
    interval_iterator& operator=(const interval_iterator& anotherIterator)
    {
        mCurrent = anotherIterator.mCurrent;
        mInterval = anotherIterator.mInterval;
        return *this;
    } 
    // Opération de permutation. 
    // A la fin de l'opération, 
    // - anotherIterator fait référence à l'élément 
    // qui était référencé par l'itérateur courant avant l'opération,
    // - l'itérateur courant  fait référence à l'élément 
    // qui était référencé par l'itérateur anotherIterator avant l'opération,
    void swap(interval_iterator& anotherIterator)
    {
        std::swap(mCurrent, anotherIterator.mCurrent);
        std::swap(mInterval, anotherIterator.mInterval);
    }

Et normalement l'ensemble des éléments ont été définis pour à la classe interval_iterator pour que ce dernier puisse répondre aux exigences auxquelles un itérateur de type forward iterator doit répondre.