2. C++ Avancé




Itérateurs

Un itérateur est un objet qui peut traverser (itérer sur) un container sans avoir à connaître l'implantation du container.

Il peut être vu comme un pointeur sur un élément d'un container et utilise des fonctions :

Chaque container possède 4 fonctions à utiliser avec les itérateurs :

Chaque container possède au moins 2 types d'itérateurs :

Utilisation


Warning: file_get_contents(ens/inra/c2_stl_iterators.cpp): failed to open stream: No such file or directory in /home/jeanmichel.richer/public_html/html_business.php on line 443
  1.  

Classe générique

Il est préférable de déclarer l'ensemble des méthodes inline dans un fichier header .h :

  1. #ifndef VECTOR_H
  2. #define VECTOR_H
  3.  
  4. /**
  5.  ***********************************************
  6.  * Vector of elements
  7.  ***********************************************
  8.  */
  9. template<class T>
  10. class Vector {
  11. // =============================================
  12. // data members
  13. // =============================================
  14. protected:
  15.     // maximum number of elements
  16.     int max_size;
  17.     // dynamic array of elements
  18.     T *elements;
  19.    
  20. // =============================================
  21. // methods
  22. // =============================================   
  23. public:
  24.     // -----------------------------------------
  25.     // default constructor with 10 elements
  26.     // -----------------------------------------
  27.     Vector(int sz = 10) {
  28.         max_size = sz;
  29.         elements = new T [ max_size ];
  30.     }
  31.    
  32.     // -----------------------------------------
  33.     // copy constructor
  34.     // -----------------------------------------
  35.     Vector(Vector& v) {
  36.         max_size = v.max_size;
  37.         elements = new T [ max_size ];
  38.         for (int i=0; i<max_size; ++i) {
  39.             elements[i] = v.elements[i];
  40.         }
  41.     }
  42.    
  43.     // -----------------------------------------
  44.     // assignment operator
  45.     // -----------------------------------------
  46.     Vector& operator=(Vector& v) {
  47.         if (&v != this) {
  48.             delete [] elements;
  49.             max_size = v.max_size;
  50.             elements = new T [ max_size ];
  51.             for (int i=0; i<max_size; ++i) {
  52.                 elements[i] = v.elements[i];
  53.             }
  54.         }
  55.         return *this;
  56.     }
  57.    
  58.     // -----------------------------------------
  59.     // destructor
  60.     // -----------------------------------------
  61.     ~Vector() {
  62.         delete [] elements;
  63.     }
  64.    
  65.     // -----------------------------------------
  66.     // accessor
  67.     // -----------------------------------------
  68.     T& operator[](int n) {
  69.         return elements[n];
  70.     }
  71.    
  72.     // -----------------------------------------
  73.     // getter
  74.     // -----------------------------------------
  75.     int get_size() {
  76.         return max_size;
  77.     }
  78. };
  79. #endif
  80.