Szablony klas na przykładzie własnej kolejki LIFO (stosu)

Stronę tą wyświetlono już: 807 razy

Wstęp

Zanim przejdę do konkretnego przykładu, który nie jakoby przyobiecałem muszę opisać pokrótce sposób tworzenia szablonów klas. Wcześniej już omawiane były szablony funkcji na stronie Programowanie → Podstawy C++ → Szablony funkcji a więc słowa kluczowe template oraz typename powinny być Ci już znane. Oto prosty przykład deklaracji szablonu klasy:

Listing 1
  1. #include <iostream>
  3. template <typename typ1, class typ2> class A // tutaj zadeklarowałem użycie dwóch typów danych
  4. {
  5. private:
  6. typ1 t1; // tutaj będzie deklarowana zmienna typu typ1
  7. public:
  8. typ2 t2; // a tu obiekt klasy typu typ2
  9. // To jest konstruktor szablonu klasy A
  10. A(typ1 t1, typ2 &t2):t1(t1),
  11. t2(t2)
  12. {};
  14. inline typ1 GetT1(){return t1;}; // to jest metoda zwracająca wartość pola t1
  15. void SetT1(typ1 t1){this->t1 = t1;}; // to jest metoda ustawiająca wartość pola t1
  16. };
  18. class B // przykładowa klasa testowa
  19. {
  20. private:
  21. int value;
  22. int value2;
  23. public:
  24. B():value(0),value2(0){}; // prosty domyślny konstruktor
  25. };
  27. int main(){
  28. B b;
  29. A<int, B>(10,b); // tworzenie konkretnego obiektu według szablonu klasy A
  31. cout<<"Wcisnij enter, aby zamknac program...";
  32. cin.get();
  34. return 0;
  35. }

Tworzenie własnej klasy kolejki LIFO

LIFO (skrót od last in first out - ostatni wchodzi pierwszy wychodzi) to sposób przechowywania danych w taki sposób, że ostatni element danych zawiera wskaźnik do wcześniej dodanych elementów. Efektem tego, aby zdjąć i-ty element stosu trzeba najpierw zdjąć wszystkie jego nadrzędne elementy. Sytuację tą często porównuje się do stosu książek, aby spod takiego stosu wyjąć jakąś książkę, trzeba najpierw zdjąć te leżące nad.

Oto przykład szablonu klasy stack oraz dodatkowo definicji klasy typy point2d:

Listing 2
  1. #include <iostream>
  3. using namespace std;
  5. template <typename type> class stack{
  6. private:
  7. type value; // element zawarty w stosie
  8. stack* st; // wskaźnik do wcześniej dodanych elementów stosu
  9. public:
  10. stack(type value):st(NULL),value(value){}; // konstruktor tworzący pierwszy element stosu
  11. stack(type value,stack* st):st(st),value(value){}; // konstruktor tworzący kolejny element stosu
  13. void Add(stack** pts, type value){stack* s = new stack(value,this);*pts = s;}; // dodawanie elementu stosu
  14. void RemoveStack(stack** pts){stack* st2 = st; st = NULL, delete this; *pts = st2;}; // usuwanie elementu stosu
  16. ~stack(){if(st){delete st; st=NULL;}cout<<"Pointer stack is deleted"<<endl;}; // zwalnianie pamięci stosu
  18. void WriteAllStack(){value.Write();if(st){st->WriteAllStack();}}; // wypisywanie elementów stosu
  20. int Size(){int s = 1; stack* st2 = st;while(st2){s++; st2 = st2->st;}return s;}; // pobieranie liczby elementów stosu
  21. };
  23. class point2d{
  24. protected:
  25. double x; // współrzędna x
  26. double y; // współrzędna y
  27. public:
  28. point2d():x(0),y(0){}; // Konstruktor ustawiajacy domyślne współrzędne
  29. point2d(point2d &p):x(p.x),y(p.y){}; // Konstruktor kopiujący
  30. point2d(double x,double y):x(x),y(y){}; // Konstruktor ustawiający podanymi liczbami
  32. void operator = (point2d &p){x = p.x; y = p.y;}; // Operator podstawiający
  33. void operator *=(double k){x *= k; y *= k;};
  35. void Write(){std::cout<<"x="<<x<<"; y="<<y<<"n";}; // Wypisywanie współrzędnych punktu na ekranie
  37. inline double GetX() const {return x;}; // Pobieranie wartości współrzędnej x
  38. inline double GetY() const {return y;}; // Pobieranie wartości współrzędnej y
  40. void SetX(double x){this->x=x;}; // Ustawianie wartości współrzędnej x
  41. void SetY(double y){this->y=y;}; // Ustawianie wartości współrzędnej y
  43. ~point2d(){}; // Destruktor
  44. };

W powyższym kodzie znalazła się taka oto metoda szablonu klasy A:

Listing 3
  1. void WriteAllStack(){value.Write();if(st){st->WriteAllStack();}}; // wypisywanie elementów stosu

Warto się jej przyjrzeć, ponieważ w ta metoda wywołuje metodę wewnętrzną obiektu pola klasy value.Write(), a to z kolei oznacza, że do stosu mogą być dodawane jedynie takie obiekty klas, które w swej definicji mają zadeklarowaną funkcję Write().

Poniżej zamieszczam przykładowy kod pokazujący operacje na stosie:

Listing 4
  1. int main(){
  2. // Dodawanie elementów stosu
  3. point2d p(0,0);
  4. sPoints = new stack<point2d>(p); // tworzenie pierwszego elementu stosu zawierającego obiekt klasy typu point2d
  5. for(int i = 0; i < 10; i++){
  6. point2d p(i,i);
  7. sPoints->Add(&sPoints, p); // dodawanie nowego elementu stosu
  8. }
  10. cout<<endl<<"Wypisywanie elementow stosu:"<<endl<<endl;
  11. sPoints->WriteAllStack(); // wypisuję elementy stosu
  13. cout<<endl<<"Usuwanie elementu stosu:"<<endl<<endl;
  14. sPoints->RemoveStack(&sPoints); // usuwa ostani element stosu
  16. cout<<endl<<"Wypisywanie elementow stosu:"<<endl<<endl;
  17. sPoints->WriteAllStack(); // wypisuję elementy stosu
  19. cout<<endl<<"Usuwanie elementu stosu:"<<endl<<endl;
  20. sPoints->RemoveStack(&sPoints);
  22. cout<<endl<<"Wypisywanie elementow stosu:"<<endl<<endl;
  23. sPoints->WriteAllStack();
  25. cout<<endl<<"Liczba elementow stosu: "<<sPoints->Size()<<endl; // tutaj metoda Size() określa ile elementów znajduje się w stosie
  27. cout<<endl<<"Zwalnianie pamieci stosu:"<<endl<<endl;
  28. if(sPoints){ // jeżeli sPoinr ma przypisaną pamięc to
  29. delete sPoints; // zwolnij pamięć
  30. sPoints = NULL; // i przypisz zero
  31. }
  33. cout<<endl;
  35. cout<<"Wcisnij enter, aby zamknac program...";
  36. cin.get();
  38. return 0;
  39. }
Tematy powiązane

Komentarze