Partie II – Création d’itérateurs

Pour la classe interval_iterator nous devons implanter les exigences relatives à un forward iterator.

1. En ce qui concerne les définitions de type, il est attendu que l'itérateur expose les types suivants :
   

   difference_type // un type d'entier signé servant à indiquer la distance entre deux itérateurs 
   value_type 	// le type des valeurs qui sont référencés par l'itérateur
                   // habituellement ''T''
   pointer 	// le type d'un pointeur pointant sur les valeurs qui sont référencés par l'itérateur
                   // habituellement ''T*''
   reference 	// le type d'une référence sur les valeurs qui sont référencés par l'itérateur,
                   // habituellement ''T&''
   iterator_category 	// Le type qui indique la nature de l'itérateur, comme [https://en.cppreference.com/w/cpp/iterator/iterator_tags|std::random_access_iterator_tag]], [https://en.cppreference.com/w/cpp/iterator/iterator_tags|std::bidirectional_iterator_tag]], [https://en.cppreference.com/w/cpp/iterator/iterator_tags|std::forward_iterator_tag]]  ou enfin [https://en.cppreference.com/w/cpp/iterator/iterator_tags|std::input_iterator_tag]].

   
   
   Pour effectuer la définition de ces types, nous pouvons soit les définir directement (attention: les valeurs stockées dans l'interval n'est pas modifiable, il s'agit donc de const int. :
   

   class interval_iterator
   {
   public:
       typedef ptrdiff_t difference_type;
       typedef const int value_type;
       typedef const int* pointer;
       typedef const int& reference;
       typedef std::forward_iterator_tag iterator_category;
   };

   
   
   On peut voir que l'on aurait pu faire références aux définitions faites dans la classe interval, ce qui aurait donné le code suivant :
   

   class interval_iterator
   {
   public:
       typedef ptrdiff_t difference_type;
       typedef interval::value_type value_type;
       typedef value_type* pointer;
       typedef value_type& reference;
       typedef std::forward_iterator_tag iterator_category;
   };

   
   L'avantage est que dans ce cas là, si nous modifions le type manipulé par la classe interval, automatiquement, les types sont bien mis à jour dans la classe interval_iterator
   
   Pour éviter d'avoir trop à écrire, nous pouvons au contraire hériter de la classe std::iterator qui fournit une implantation par défaut de ces types.
   

   class interval_iterator: 
       std::iterator<const int, std::forward_iterator_tag>
   {
   public:
      ...
   };

   
   Cependant cette méthode est déclarée obsolète depuis l'introduction de C++17.

2. 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;
       }

3. 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.

</hidden>

===== Question 2.0 =====

Tester le bon fonctionnement de classe avec le code suivant :

#include"interval.hpp"
#include<algorithm>
#include<iostream>
#include<vector>
 
template<class inputIterator>
void print(inputIterator beginIt, inputIterator endIt)
{
    if(beginIt == endIt)
    {
        std::cout << "[]" << std::endl;
        return;
    }    
    for(;;)
    {
        std::cout << *beginIt;
        beginIt++;
        if(beginIt == endIt)
            break;
        std::cout << ", ";
    }
    std::cout << "]" << std::endl;
    return;
}
 
void testInterval()
{
    interval inter(5, 15);
    std::cout << "Contenu de l'interval : "; 
    print(inter.begin(), inter.end());
    // Recherche du plus grand élément.
    auto maxIt = max_element(inter.begin(), inter.end());
    std::cout << "Element maximal de la séquence: " << *maxIt << std::endl;
    // Duplication des valeurs dans un vecteur
    std::vector<int> vec(inter.begin(), inter.end());
    std::cout << "Contenu du vecteur : "; 
    print(vec.begin(), vec.end());
}
 
int main()
{
    testInterval();
    return 0;
}