Wzorce

Wzorce klas – dlaczego? Pisząc programy często korzystamy z abstrakcyjnych typów danych, takich jak stos, kolejka czy drzewo. Implementacje takich typów mogą być prawie identyczne, na przykład klasy lista_liczb i lista_znaków mogą różnić się tylko typem elementu przechowywanego na liście. Wzorzec klasy to sposób na napisanie uogólnionej . sparametryzowanej klasy — klasy której parametrem będzie typ, bądź inna klasa. Można napisać wzorzec listy, a potem w zależności od tego czego aktualnie potrzebujemy zadeklarować listę znaków, bądź listę figur. Wzorce są doskonalszym i wygodniejszym sposobem (od stosowania preprocesora) tworzenia rodzin typów i funkcji. Wzorce nazywane są również szablonami (ang. templates).

Wzorce klas – jak deklarować? template <class T> // wzorzec, którego argumentem jest typ T class stos // wzorzec klasy stos { T* v; // początek stosu T* p; // koniec stosu int rozm; // pojemność stosu public: stos (int r) {v = p = new T[rozm=r];} // konstruktor z argumentem: // rozmiar stosu ~stos () {delete[]v;} // destruktor void wstaw(T a) {*p++ = a;} // wstaw na stos T zdejmij() {return *--p;} // zdejmij ze stosu int rozmiar() const {return p-v;} // ile elementów typu T jest na stosie };

Wzorce klas – jak deklarować? template <class T> // deklarujemy wzorzec, // którego argumentem jest typ T class stos // wzorzec klasy stos Typu (klasy) T można używać do końca deklaracji klasy stos tak jak każdego innego dostępnego typu lub klasy. W zakresie wzorca „template<T> stos<T>” używanie pełnej nazwy typu „stos<T>” jest nadmiarowe zarówno przy definicji metod wewnątrz klasy jak i poza nią, wystarczy „stos” zarówno dla określenia klasy jak i nazw konstruktorów i destruktora.

Wzorce klas – jak deklarować? Mając wzorzec klasy stos można deklarować stosy różnych elementów przekazując typ elementu jako aktualny parametr wzorca. Składnia nazwy typu wywiedzionego ze wzorca jest następująca: nazwa_klasy_wzorca<argument_wzorca> Nazwa klasy stosu liczb: stos<int> Nazwa klasy stosu wskaźników do figur: stos<figura *>

stos<int> liczby(100); Wzorce klas Deklaracja: stos<int> liczby(100); to deklaracja obiektu o nazwie liczby, należącego do klasy stos<int>, oraz wywołanie konstruktora stos<int>(100). Nazwy klasy utworzonej ze wzorca można używać tak samo jak nazwy każdej innej klasy, różnica to inna składnia nazwy.

stos<figura*> spf(200); // stos wskaźników do figur zdolny // pomieścić 200 wskaźników stos<Punkt> sp(400); // stos punktów o pojemności 400 void f(stos<complex> &sc) // funkcja f, której argumentem jest // referencja do stosu liczb zespolonych { sc.wstaw(complex(1,2)); // wstaw do stosu przekazanego jako argument // funkcji liczbę zespoloną complex z = 2.5 * sc.zdejmij(); // zdejm liczbe ze stosu, // pomnóż ją i przypisz stos<int> *p=0; // deklaracja wskaźnika do // stosu liczb całkowitych p=new stos<int>(800); // konstrukcja stosu 800 liczb całkowitych for (int i=0; i<400; i++) // 400 razy p->wstaw(i); // wstaw liczbe i do stosu liczb sp.wstaw(Punkt(i,i+400)); // i punkt do stosu punktów } delete p; // destrukcja stosu liczb

Wzorce Kompilator sprawdza poprawność wzorca w momencie jego użycia, a więc błędy w samej deklaracji wzorca mogą pozostać niezauważone aż do momentu próby wykorzystania wzorca. Poprawna kompilacja pliku zawierającego wzorzec nie oznacza że wzorzec nie zawiera błędów. Częstą praktyką jest najpierw uruchomienie konkretnej klasy, np. stos_znaków, a potem przekształcenie jej w klasę ogólną - wzorzec stos<T>.

Wzorce W wcześniejszej wersji wzorca wszystkie metody są inline — zdefiniowano je wewnątrz deklaracji klasy. Można we wzorcu nie definiować metod: template <class T> class stos { T* v; // początek stosu T* p; // koniec stosu int rozm; // pojemność stosu public: stos (int r); // deklaracja: konstruktor z argumentem: rozmiar stosu ~stos (); void wstaw(T a); // deklaracja: wstaw na stos T zdejmij(); // deklaracja: zdejmij ze stosu int rozmiar(); // deklaracja: ile elementów typu T jest na stosie };

Wzorce Jeżeli metody wzorca definiujemy poza definicją klasy wzorca to musimy użyć dla każdej z metod słowa kluczowego template: // definicja metody wstaw template<class T> void stos<T>::wstaw(T a) { *p++ = a; }; // konstruktor stos<T>::stos(int r) v = p = new T[rozm=r];

template<T> stos<T>” Wzorce Przypomnienie: W zakresie wzorca template<T> stos<T>” używanie pełnej nazwy typu „stos<T>” jest nadmiarowe zarówno przy definicji metod wewnątrz klasy jak i poza nią. Wystarczy „stos” zarówno dla określenia klasy jak i nazw konstruktora i destruktora („<T>” jest domyślne). Poniższy wzorzec jest błędny: // template<class T> // stos<T>::stos<T>(int r) // to jest traktowane jako błąd, // // powinno być stos<T>:: stos(int r) //{ // v = p = new T[rozm=r]; //};

Rozbudowywanie klas-wzorców Wzorca który jest już napisany i wykorzystywany nie należy modyfikować — modyfikacje te będą dotyczyły wszystkich klas stworzonych w oparciu o ten wzorzec. Gdy dodamy zmienne klasowe to powiększą się obiekty wszystkich tych klas wywiedzionych ze wzorca. Gdy zmienimy definicje metod to zmiany będą dotyczyły wsystkich klas wywiedzionych ze wzorca. Zatem, zamiast modyfikacji wzorca danej klasy należy utworzyć wzorzec klasy pochodnej, o nowych właściwościach.

Rozbudowywanie klas-wzorców Np.: potrzebujemy stosu łańcuchów z możliwością zapisu i odczytu do pliku template<class T> class stos_plik: public stos<T> { char * nazwa_pliku; public: /* konstruktor, parametry: rozmiar i nazwa pliku */ stos(int rozmiar, char * nazwa = NULL) :stos<T>(rozmiar) // konstrukcja rodzica { // tutaj, lub za pomocą listy inicjalzacyjnej zachowaj nazwę pliku } void zapisz_stos(); void wczytaj_stos(); };

Wzorzec szczegółowy Jeżeli wzorzec działa niepoprawnie dla jakiegoś szczególnego parametru, to można zdefiniować inną wersję wzorca dla konkretnego parametru. Np. klasa która służy do porównywania elementów danego typu: template<class T> class porównywacz // wzorzec ogólny { public: static mniejszy(T &a, T &b) return a<b; } }; Powyższe jest poprawne dla typów takich, jak int czy char. Dla łańcuchów (char *) porównywane by były nie łańcuchy, ale ich adresy,

Wzorzec szczegółowy Dla łańcuchów (char *) porównywane by były nie łańcuchy, ale ich adresy, więc definiujemy szczególną postać wzorca klasy porównywacz dla łańcuchów: class porównywacz<char *> // wzorzec szczegółowy { public: static mniejszy(const char * a, const char * b) return strcmp(a, b)<0; } }; Kompilator wykorzysta szczególną postać wzorca, jeżeli w miejscu gdzie będzie potrzebna, będzie widoczna (czyli zadeklarowana wcześniej). W przeciwnym przypadku zostanie rozwinięty wzorzec ogólny.

Argumenty wzorca Argumentów wzorca może być wiele, oprócz klas i typów mogą to być napisy, nazwy funkcji lub wyrażenia stałe. Np. wzorzec bufora, którego parametrem będzie rozmiar: template<class T, int rozm> class bufor { T w[rozm]; // ... } taki wzorzec bufora wykorzystujemy np. tak: bufor<figura, 250> tbf; // deklaracja obiektu f będącego // buforem na 250 figur bufor<char,100> tbc; // bufor na 100 znaków

Wzorce Dwa typy wygenerowane ze wspólnego wzorca są identyczne jeżeli identyczne są argumenty wzorca, w przeciwnym przypadku są różne i nie wiąże ich pokrewieństwo. Na przykład dla następujących deklaracji tylko obiekty tbc0 i tbc1 należą do tej samej klasy (klasy bufor<char, 100>) pozostałe obiekty do obiekty różnych klas. bufor<char,100> tbc0; bufor<figura, 250> tbf0; bufor<char,100> tbc1; bufor<figura, 300> tbf1;

Wzorce funkcji template <class T> // jesteśmy poza deklaracją klasy void zamień(T &x, T &y) // nie metoda, a funkcja { T t=x; x=y; y=t; } int a=7,b=8; zamień(a,b); // kompilator rozwinie wzorzec //(jeżeli jest widoczny)

Wzorce funkcji - przykład napisać rodzinę funkcji zwiększających wartość swojego pierwszego argumentu aktualnego o wartość drugiego argumentu (oba to typy liczbowe) template <class t> void zwieksz(t &i, double d) // zadzaiala dla wszystkich typów liczbowych { // ale jak ktos wywola zwieksz(1, 1) i+=t(d); // to będą 2 automatyczne konwersje }; // nieekologiczne --- marnotrawstwo czasu template <class t, class d> void zwieksz_szybciej (t &i, const d delta) // const nie zaszkodzi { // a może się przyda i+=t(delta); };

Wzorce funkcji - przykład napisać rodzinę funkcji zwiększających wartość swojego pierwszego argumentu aktualnego o wartość drugiego argumentu (oba to typy liczbowe), lub o 1 gdy nie podano drugiego argumentu. // template <class t, class d> // void zwieksz_1 (t &i, const d delta=1) // … Pułapka: po napotkaniu wywołania zwieksz_1(3.1415926); kompilator nie ma podstaw do określenia typu d!

Wzorce funkcji - przykład napisać rodzinę funkcji zwiększających wartość swojego pierwszego argumentu aktualnego o wartość drugiego argumentu (oba to typy liczbowe), lub o 1 gdy nie podano drugiego argumentu. template <class t, class d> void zwieksz_1(t &i, const d delta) { i+=t(delta); }; template <class t> void zwieksz_1(t &i) { i+=t(1); };