Ecole Nationale d Ingénieurs de Brest. Programmation par objets Le langage C++ Type Concret de Données en C++

Transcription

1 Notes de cours Ecole Nationale d Ingénieurs de Brest Programmation par objets Le langage C++ Type Concret de Données en C++ J. Tisseau 1995/1997 enib c jt /30

2 Du TAD au TCD Type Abstrait de Données + Choix d une représentation physique + Implémentation dans le langage cible = Type Concret de Données enib c jt /30

3 Type Abstrait de Données Type Abstrait de Données + Choix d une représentation physique + Implémentation dans le langage cible = Type Concret de Données enib c jt /30

4 Le TAD Array[T] (t 1, t 2,..., t i, t i+1,..., t n ) Un tableau (Array[T]) est une suite finie et ordonnée d éléments (de type T) accessibles par un indice entier (Integer). Les éléments sont ordonnés dans l ordre croissant des indices. Deux éléments successifs correspondent à des indices successifs (..., t i, t i+1,... ). Le premier élément a l indice 1. enib c jt /30

5 Les services du TAD Array[T] Inspectors : empty : Array[T] Boolean full : Array[T] Boolean size : Array[T] Integer capacity : Array[T] Integer element : Array[T] Integer T Modifiers : setelement : Array[T] Integer T Array[T] insert : Array[T] Integer T Array[T] erase : Array[T] Integer Array[T] enib c jt /30

6 Les preconditions du TAD Array[T] Preconditions : array Array[T], n Integer, t T element(array,n) est défini si et seulement si ( empty(array)) (1 n size(array)) setelement(array,n,t) est défini si et seulement si ( empty(array)) (1 n size(array)) insert(array,n,t) est défini si et seulement si ( full(array)) (1 n (size(array) + 1)) erase(array,n) est défini si et seulement si ( empty(array)) (1 n size(array)) enib c jt /30

7 Les axiomes du TAD Array[T] Axioms : array Array[T], n Integer, t T empty(array) (size(array) = 0) full(array) (size(array) = capacity(array)) ( empty(array)) (1 n size(array)) (size(erase(array,n)) = size(array) - 1) ( full(array)) (1 n (size(array) + 1)) (size(insert(array,n,t)) = size(array) + 1) enib c jt /30

8 Les axiomes du TAD Array[T] Axioms : array Array[T], n,i Integer, t T ( empty(array)) (1 n size(array)) (1 i < n) (element(erase(array,n),i) = element(array,i)) ( empty(array)) (1 n size(array)) (n i (size(array) - 1)) (element(erase(array,n),i) = element(array,i + 1)) enib c jt /30

9 Les axiomes du TAD Array[T] Axioms : array Array[T], n,i Integer, t T ( full(array)) (1 n size(array) + 1) (1 i < n) (element(insert(array,n,t),i) = element(array,i)) ( full(array)) (1 n size(array) + 1) (i = n) (element(insert(array,n,t),i) = t) ( full(array)) (1 n size(array) + 1) (n < i size(array) + 1) (element(insert(array,n,t),i) = element(array,i-1)) enib c jt /30

10 Choix d une représentation physique Type Abstrait de Données + Choix d une représentation physique + Implémentation dans le langage cible = Type Concret de Données enib c jt /30

11 Tableau dynamique capacity { }} { array t 1 t 2 t 3 }{{} size enib c jt /30

12 Implémentation dans le langage cible Type Abstrait de Données + Choix d une représentation physique + Implémentation dans le langage cible = Type Concret de Données enib c jt /30

13 L interface de la classe Array<T> // file Array.h #ifndef ARRAY H #define ARRAY H #include <stdlib.h> #include <iostream.h> #include <stl/bool.h> // size t // ostream // bool enib c jt /30

14 L interface de la classe Array<T> template <class T> class Array { public: // Allocators Array(size t capacity = 0); Array(const Array<T>& array); Array& operator=(const Array<T>& array); virtual ~Array(void); // Output friend ostream& operator<<(ostream& stream, const Array<T>& array); enib c jt /30

15 L interface de la classe Array<T> public: // Inspectors size t size(void) const; size t capacity(void) const; bool empty(void) const; bool full(void) const; const T& element(size t n) const; // Comparisons bool operator==(const Array<T>& array) const; bool operator!=(const Array<T>& array) const; enib c jt /30

16 L interface de la classe Array<T> public: // Modifiers void setelement(size t n, const T& t); void insert(size t n, const T& t); void erase(size t n); // Accessors const T& operator[](size t n) const; T& operator[](size t n); enib c jt /30

17 L interface de la classe Array<T> private: // Attributes size t capacity; // capacité du tableau size t size; // nombre d éléments du tableau T* array; // tableau C dynamique }; #endif // end of file Array.h enib c jt /30

18 L implémentation de la classe Array<T> // file Array.C #include <assert.h> #include "Array.h" template <class T> Array<T>::Array(size t capacity) : capacity(capacity), size(0), array(new T[ capacity]) {} template <class T> Array<T>::~Array(void) { if( array) delete [] array; } enib c jt /30

19 L implémentation de la classe Array<T> template <class T> Array<T>::Array(const Array<T>& array) : capacity(array. capacity), size(array. size), array(new T[ capacity]) { for(size t i = 0; i < size; i++) array[i] = array. array[i]; } enib c jt /30

20 L implémentation de la classe Array<T> template <class T> Array& Array<T>::operator=(const Array<T>& array) { if(this!= &) { if( array) delete [] array; capacity = array. capacity; size = array. size; array = new T[ capacity]; for(size t i = 0; i < size; i++) } array[i] = array. array[i]; } return *this; enib c jt /30

21 L implémentation de la classe Array<T> template <class T> ostream& operator<<(ostream& stream, const Array<T>& array) { stream << ( ; if(!array.empty()) { for(size t i = 0; i < array.size() - 1; i++) stream << array.element(i) <<, ; stream << array.element(array.size() - 1); } return stream << ) ; } enib c jt /30

22 L implémentation de la classe Array<T> template <class T> size t Array<T>::size(void) const { return size; } template <class T> size t Array<T>::capacity(void) const { return capacity; } template <class T> bool Array<T>::empty(void) const { return size == 0; } template <class T> bool Array<T>::full(void) const { return size == capacity; } enib c jt /30

23 L implémentation de la classe Array<T> template <class T> const T& Array<T>::element(size t n) const { assert((!empty()) && (n >= 0) && (n < size())); return array[n]; } template <class T> void Array<T>::setElement(size t n, const T& t) { assert((!empty()) && (n >= 0) && (n < size())); array[n] = t; } enib c jt /30

24 L implémentation de la classe Array<T> template <class T> void Array<T>::insert(size t n, const T& t) { assert((!full()) && (n >= 0) && (n <= size())); for(size t i = size(); i > n; i--) array[i] = array[i-1]; array[n] = t; size++; } enib c jt /30

25 L implémentation de la classe Array<T> template <class T> void Array<T>::erase(size t n) { assert((!empty()) && (n >= 0) && (n < size())); for(size t i = n; i < size(); i++) array[i] = array[i+1]; size--; } enib c jt /30

26 L implémentation de la classe Array<T> template <class T> const T& Array<T>::operator[](size t n) const { assert((!empty()) && (n >= 0) && (n < size())); return array[n]; } template <class T> T& Array<T>::operator[](size t n) { assert((!empty()) && (n >= 0) && (n < size())); return array[n]; } enib c jt /30

27 L utilisation de la classe Array<T> // Main.C #include "Array.h" void main(void) { Array<int> array(10); int x = 1; while((x!= 0) && (!array.full())) { cout << "> "; cin >> x; array.insert(0,x); } while(!array.empty()) { cout << array.element(0) << endl; array.erase(0); } } enib c jt /30

28 L utilisation de la classe Array<T> # makefile Main : Array.o Main.o CC Array.o Main.o -o Main Array.o : Array.h Array.C CC -c Array.C Main.o : Array.h Main.C CC -c Main.C enib c jt /30

29 L utilisation de la classe Array<T> $ make $ Main > 1 > 2 > $ CC -c Array.C CC -c Main.C CC Array.o Main.o -o Main enib c jt /30

30 Bibliographie Carroll, Ellis M.J. Designing reusable C++, Addison Wesley, 1995 Coplien J.O. Programmation avancée en C++ : styles et idiomes, Addison Wesley, 1992 Lippman S.B. Le modèle objets du C++, International Thomson Publishing, 1997 Stroustrup B. Le langage C++, Addison Wesley, 1992 enib c jt /30