Pracę wykonali: Rafał Chmielorz Michał Sporek Jan Nowik Szablony (wzorce) Pracę wykonali: Rafał Chmielorz Michał Sporek Jan Nowik

Szablon funkcji Po co stosować szablon funkcji ? Mamy funkcje która zwraca większa z dwóch liczb int wieksza(int a , int b) {return (a > b) ? a : b ; } Teraz chcąc wywołać tą funkcję np. dla danych typu float, double … będziemy musieli napisać kolejne funkcje zmieniając jedynie parametry Stosując szablon funkcji problem znika Definicja szablonu dla naszej funkcji template<class jakis_typ>jakis_typ wieksza(jakis_typ a , jakis_typ b) Zobaczmy jak wygląda to w praktyce

# include <iostream.h> template<class jakis_typ> jakis_typ wieksza(jakis_typ a , jakis_typ b) {return (a > b) ? a : b ; } //******************************************************** main() { int a=44 , b=88 ; double x=12.4 , y=67.43; unsigned long la=98765 , lb=4567 ; cout<<"wiekszy int :"<<wieksza(a,b)<<endl; cout<<"wiekszy double :"<<wieksza(x,y)<<endl; cout<<"wiekszy long :"<<wieksza(la,lb)<<endl; } Po wykonaniu programu na ekranie zobaczymy wiekszy int : 88 wiekszy double : 67.43 wiekszy long : 98765

Przeładowanie szablonów template<class T> T wieksza(T a , T b) template<class T> T wieksza(T a , T b , int c) poprawnie template<class T> T wieksza(T a , int b) błąd Powstał konflikt Chcąc wywołać funkcję wieksza(10,45) kompilator nie wie o który szablon nam chodzi i w rezultacie zaprotestuje

Funkcje specjalizowane Mając nasz szablon template<class jakis_typ> jakis_typ wieksza(jakis_typ a , jakis_typ b) {return (a > b) ? a : b ; } wywołamy funkcję char string1[30] = {„tak”}; char string2[30] = {„Czy to jest dobrze ?”}; cout<<wieksza(string1,string2); W rezultacie funkcja wieksza zwróci wskaźnik o większej wartości a nie dłuższy string Co robić w takiej sytuacji !!! Korzystać z funkcji specjalizowanej

# include <iostream.h> # include <string.h> template<class jakis_typ> jakis_typ wieksza(jakis_typ a , jakis_typ b) {return (a > b) ? a : b ; } char *wieksza(char* a , char* b) { if(strlen(a)>strlen(b)) return a; else return b; } //*************************************************** main() { int a=44 , b=88 ; char string1[30] = {"tak"}; char string2[30] = {"To jest dobrze "}; cout<<"wiekszy int : "<<wieksza(a,b)<<endl; cout<<"wiekszy string: "<<wieksza(string1,string2); Wynik działania programu wiekszy int : 88; wiekszy string : To jest dobrze

Szablon klas Klasa do chowania zmiennych typu int class schowek { int sejf; public: void schowaj(int x) {sejf=x;} oddaj() {return sejf; } Klasa do chowania zmiennych typu char class schowek_na_chr { char sejf; void schowaj(char x) {sejf=x;}

Teraz zobaczmy na przykładzie jak można zrobić szablon klas #include<iostream.h> template<class jakis_typ>class schowek { jakis_typ sejf; public: void schowaj(jakis_typ x) {sejf=x;} oddaj() {return sejf; } } //********************************* main() {schowek<int> czerwony ; schowek<char> znakowy ; czerwony.schowaj(7); int m ; m=czerwony.oddaj(); znakowy.schowaj('T'); cout<<"schowany int :"<<m; cout<<"schowany znak :"<<znakowy.oddaj(); return 0; Wynik działania: schowany int : 7 schowany znak : T

Specjalizowana klasa szablonowa #include <iostream.h> #include <string.h> template<class jakis_typ> class akmulator { jakis_typ zloze; public: akmulator() : zloze (0) {}; void przyjm(jakis_typ co) {zloze=zloze+co ;} jakis_typ rozladunek() ; }; template<class jakis_typ> jakis_typ akmulator<jakis_typ>::rozladunek() { jakis_typ pomocnik=zloze; zloze=0; return pomocnik; } //akmulator<char*> mick //blad !!! //***************** specjalizowana klasa*************************** //nastepny slajd

class akmulator<char*>//******* specjalizowana klasa******************* { char* zloze; public: akmulator<char*>(); void przyjm(char* nowy); char* rozladunek() { char*chwila=zloze; zloze=0; return chwila; } };//****************************************** akmulator<char*>::akmulator(): zloze(NULL){} //********************************************* void akmulator<char*>::przyjm(char* nowy) { if(!zloze) {zloze=new char[strlen(nowy)+1]; zloze[0]=NULL; else {char *stary=zloze; zloze=new char[strlen(stary)+strlen(nowy)+1]; strcpy(zloze,stary); delete stary; } strcat(zloze,nowy); };

main() { akmulator<float> kasa; kasa.przyjm(400.00); //styczen float przelew=50.50; kasa.przyjm(przelew); cout<<"utarg miesieczny w styczniu = "<<kasa.rozladunek()<<endl ; akmulator<char*>wysp; //Wyspianski miewa natchnienia dwa razy dziennie //rano wysp.przyjm("Przecierz już dawno się wyzbylem marzen"); char *zapisek_ranny=wysp.rozladunek(); cout<<"***Rano Wyspianski ulozyl:***\n"<<zapisek_ranny; //wieczorem wysp.przyjm("Zyje by zwalo się ze zyje"); char *zapisek_wieczorny=wysp.rozladunek(); cout<<"***Wieczorem Wyspianski ulozyl:***\n"<<zapisek_wieczorny; return 0;} Efekt działania Utarg miesieczny w styczniu = 450.5 ***Rano Wyspianski ulozyl*** Przecierz już dawno wyzbylem się marzen ***Wieczorem Wyspianski ulozyl*** Zyle by zwalosie ze zyje

Przyjaźń a szablony klas Wystąpi tu szablon klas deklarujący przyjaźń z -funkcją -klasą #include <iostream.h> #include <string.h> //class poletko; template<int stala> class poletko { int rola[stala]; poletko(){cout<<"Prywatny konstruktor";} void funpryw() { cout<<"Prywatna funkcja poletka"<<stala<<endl;} // ta klasa będzie przyjacielem wszystkich klas szablonowych tworzonych z szablonu poletko friend class rolnik; // ta funkcja będzie przyjacielem wszystkich klas szablonowych tworzonych z szablonu poletko friend void siew(); };

class rolnik {public: void rok() { cout<<"Dziala zaprzyjazniony rolnik:"<<endl; poletko<2> zielone; zielone.rola[0]=6; zielone.funpryw(); poletko<10> duze ; duze.funpryw(); } }; void siew() { cout<<"Dziala funkcja zaprzyjaznina siew\n"; poletko<1> doswiadzczalne; doswiadzczalne.funpryw(); main() { rolnik boryna; boryna.rok(); siew(); return 0;

Ekran po wykonaniu programu Dziala zaprzyjazniny rolnik: Prywatny konstruktor Prywatna funkcja poletka 2 Prywatny konstrultor Prywatna funkcja poletka 10 Dziala zaprzyjazniona funkcja siew Prywatna funkcja poletka 1