Programowanie Szablony PDF

## Szablony ### Brak kodu Do utworzenia funkcji szablonowej wymagana jest definicja szablonu i dedukcja typu parametrów szablonu. ### Brak kodu Szablony umożliwiają tworzenie kodu niezależnego od * jedynie typów i struktur danych * jedynie typów i algorytmów * typów, algorytmów i struktur...

## Szablony ### Brak kodu Do utworzenia funkcji szablonowej wymagana jest definicja szablonu i dedukcja typu parametrów szablonu. ### Brak kodu Szablony umożliwiają tworzenie kodu niezależnego od * jedynie typów i struktur danych * jedynie typów i algorytmów * typów, algorytmów i struktur danych * jedynie typów ### Brak kodu Parametrami szablonów mogą być: * typy i dowolne liczby * typy, tablice i dowolne liczby * typy, dowolne liczby i funkcje ```C++ template<typename T> T suma(T a, T b); ``` Szblon X: może wygenerować: * funkcje A i B, które mogą być identyczne lub różne * dwie podobne funkcje A oraz B * funkcję B, a funkcja A nie może być funkcją szablonową * zawsze dwie różne funkcje: AiB ```C++ suma(a,b) suma<double>(a,b) ``` ### Brak kodu jedynie definicja szablonu definicja jak i konkretyzacja szablonu ### Brak kodu jedynie konkretyzacja szablonu ### Brak kodu są tym samym szablon stanowi jedno z podejść programowania uogólnionego programowanie uogólnione stanowi jeden ze sposobów stosowania szablonów nie maja ze sobą nic wspólnego ### Deklaracja szablonu klasy ```C++ template<typename T1, typename T2 = T1> class mojaklasa; ``` * jest niepoprawna * jest poprawna, a jej składniki A i B będą zawsze identyczne * jest poprawna, a jej składniki A i B będą niekiedy identyczne * jest poprawna jedynie w przypadku gdy typy: T1 i T2 są identyczne ```C++ T1 pole1 T2 pole2 ``` ### Instrukcja X jest ```C++ klasa<char, 5> instKlasy("abcde"); ``` * poprawna gdy istnieje szablon A * poprawna gdy istnieje szablon B * poprawna gdy istnieje szablon C * błędna ```C++ template<typename T, int i> struct klasa{ T tab[i]; }; template <class T, int i> struct klasa{ klasa (T*); }; template <class T, int i> class klasa{ T tab[i]; }; ``` ### Konkretyzacja przedstawionego szblonu ```C++ template<typename T, T par = 3> class mojaklasa; ``` * nigdy nie będzie mogła zajść * przebiegnie poprawnie, ale tylko dla niektórych typów * zawsze będzie błedna * zawsze będzie poprawna ### Zaprezentowane szblony ```C++ template<typename T> T fun(T) template<typename T> T* fun(T*); ``` * mogą istnieć równolegle * może istnieć tylko jeden z nich - obojętnie który * tylko pierwszy z nich jest poprawny * tylko drugi z nich jest poprawny ### Konkretyzacja pojedynczej metody szablonu klasy * zawsze przebiega jawnie * zawsze przebiega niejawnie * przebiega jawnie bądź niejawnie * nie jest możliwa ### Deklaracja zaprezentowanej funkcji zaprzyjaźnionej ```C++ friend ostream& operator<<(ostream& str, wektor<Typ, rozm> w); ``` * jest prawidłowa i wystarczająca dla szablonu klasy wektor * jest prawidłowa, ale niewystarczająca dla szablonu klasy wektor * jest nieprawidłowa dla szablonu klasy wektor * jest niedopuszczalna wewnątrz szablonu klasy wektor ### Deklaracja X ```C++ template <class T, T mTab [3]> struct mStr; ``` * jest prawidłowa * jest nieprawidłowa, ale można ją zastąpić przez A * jest nieprawidłowa, ale można ją zastąpić przez B * jest nieprawidłowa, ale można ją zastąpić przez C ```C++ template <typename T, T mTab [3]> class mStr; template <class T, T mTab [3]> class mStr; template <typename T, T mTab [3]> struct mStr; ``` ### Brak kodu Szablon można zdefiniować dla * klasy, metody i funkcji globalnej * klasy i metody, ale nie dla funkcji globalnej * klasy i funkcji globalnej, ale nie dla metody * klasy, unii, metody i funkcji globalnej ### Brak kodu Szablony funkcji pozwalają na * definiowanie rodziny funkcji, ale tylko w zakresie globalnym * definiowanie tylko i wyłącznie metod klas szablonowych * definiowanie rodzin: metod klas i funkcji z zakresu globalnego * definiowanie rodzin funkcji globalnych i zaprzyjaźnionych ### Brak kodu Szablon funkcji implementuje * ten sam algorytm dla różnych typów * różne algorytmy dla różnych typów * te same bądź różne algorytmy dla różnych typów * różne algorytmy dla tych samych typów ### Brak kodu Dedukcja typu jest możliwa * tylko w przypadku szablonów klas * tylko w przypadku szablonów funkcji * zarówno w przypadku szablonów klas jak i szablonów funkcji * tylko w przypadku szablonów metod klas ### Brak kodu Szablony mogą być definiowane * jedynie w zakresie globalnym * jedynie w oddzielnym pliku * wszędzie tam gdzie funkcje i klasy ### Brak kodu Konkretyzacja szablonu polega na * utworzeniu funkcji bądź klasy szablonowej na podstawie szablonu * utworzeniu rodziny funkcji bądź klas szablonowych * uściśleniu typu szablonu * wyposażeniu szablonu w parametry ### Brak kodu Parametrami pozatypowymi szablonów mogą być: * parametry typu całkowitego, referencje i wskaźniki, ale nie literały ani parametry typu wyliczeniowego * parametry typu całkowitego, wyliczeniowego, referencje, wskaźniki i literały * parametry dowolnego typu liczbowego, wyliczeniowego, referencje i wskaźniki * parametry typu całkowitego, wyliczeniowego, referencje i wskaźniki ### Brak kodu Szablon X jest * poprawnie zdefiniowany * błędny - poprawna definicja to A * błędny - poprawna definicja to B * błędny - poprawna definicja to C ```C++ template<typename Typ, Typ *wskTyp> class myClass{}; template<typename Typ, *wskTyp> class myClass{}; template<typename Typ, typename Typ1 = *wskTyp> class myClass{}; template<typename Typ, typename *wskTyp> class myClass{}; ``` ### Brak kodu Konkretyzacja jawna i niejawna szablonu klasy zawierającego kilka metod * zawsze dają ten sam efekt końcowy * zawsze dają różne efekty końcowe * to synonimy tego samego procesu * niekiedy dają ten sam efekt końcowy ### Brak kodu Poprawna, klasyczna deklaracja przyjaźni funkcji wewnątrz szablonu i jej definicja na zewnątrz * są wystarczające i gwarantują dostęp do składników prywatnych klasy szablonowej * spowodują błąd kompilacji * spowodują błąd linkowania * są wystarczające, ale nie gwarantują dostępu do składników prywatnych klasy szablonowej ### Brak kodu Model włączania i model jawnej konkretyzacji * to dwa niezależne modele pracy z szablonami * to dwa identyczne modele pracy z szablonami * nie ma modelu jawnej konkretyzacji * stanowią rozwiązanie różnych problemów ### Poprawna definicja szablonu, którego parametrem jest inny szablon jest następująca ```C++ template <template<class T> class kl> struct stru{ kl<int> ob; }; template <class T> struct stru{ kl<int> ob; }; template <template<typename T>> struct stru{ kl<int> ob; }; template <template class kl> struct stru{ kl<int> ob; }; ``` ### Przedstawiony ciąg instrukcji jest poprawny gdy istnieje szablon ```C++ klMin ob; cout << ob.Min(3, 4) << ob. Min("Ola", "Ala"); template<typename Typ> Typ Min (Typ x, Тур у); class klMin{ template<typename Typ> Typ Min (Typ x, Typ y); }; template<typename Typ> class Min{ Typ Min (Typ x, Тур у); }; template<typename Typ> class klMin{ template<typename Typ> Typ Min (Typ x, Typ y); }; ``` ### Brak kodu klasy, metody i funkcji globalnej klasy i metody, ale nie dla funkcji globalnej klasy i funkcji globalnej, ale nie dla metody klasy, unii, metody i funkcji globalnej ### Brak kodu nigdy nie generuje kodu metod klasy zawsze generuje kod metod klasy niekiedy generuje kod metod klasy generuje kod klasy bez kodu jej metod ### Brak kodu w zakresie globalnym oraz wewnątrz innych klas i funkcji w zakresie globalnym oraz wewnątrz innych klas, ale nie wewnątrz funkcji w zakresie globalnym oraz wewnątrz funkcji, ale nie wewnątrz innych klas jedynie w zakresie globalnym ### Brak kodu zawsze utworzenie klasy szablonowej i wszystkich jej metod utworzenie klasy szablonowej i części jej metod utworzenie jedynie klasy szablonowej utworzenie klasy szablonowej i niekiedy wszystkich jej metod ### Brak kodu to dwa niezależne modele pracy z szablonami to dwa identyczne modele pracy z szablonami nie ma modelu jawnej konkretyzacji stanowią rozwiązanie różnych problemów ### Poprawna definicja szablonu, którego parametrem jest inny szablon jest następująca ```C++ template <template<class T> class kl> struct stru{ kl<int> ob; }; template <class T> struct stru{ kl<int> ob; }; template <template<typename T>> struct stru{ kl<int> ob; }; template <template class kl> struct stru{ kl<int> ob; }; ``` ### Przedstawiony ciąg instrukcji jest poprawny gdy istnieje szablon ```C++ klMin ob; cout << ob.Min(3, 4) << ob. Min("Ola", "Ala"); template<typename Typ> Typ Min (Typ x, Тур у); class klMin{ template<typename Typ> Typ Min (Typ x, Typ y); }; template<typename Typ> class Min{ Typ Min (Typ x, Тур у); }; template<typename Typ> class klMin{ template<typename Typ> Typ Min (Typ x, Typ y); }; ``` ### Poprawna częściowa specjalizacja szablonu X jest następująca ```C++ template<typename T, int I> class vect{}; template<int I> class vect<double, I>{}; template<int I> class vect<double, I>{}; template<typename T, int I> class vect<double, I>{}; template<int I> class vect<int*, I>{}; ``` ### Która z definicji klasy pochozącej od klasy "Bazowa" jest prawidłowa ```C++ template<typename bTyp> class Bazowa {}; template<typename pTyp> class Pochodna: public Bazowa {}; template<typename pTyp> class Pochodna: public Bazowa<bTyp> {}; template<typename pTyp> class Pochodna: public Bazowa<pTyp> {}; ``` ### Deklaracja X jest ```C++ template <class T, mFun(T)> struct mStr; template <typename T, mFun(T)> struct mStr; template <typename T, mFun(T)> class mStr; template <class T, mFun(T)> class mStr; ``` ### Deklaracja X jest ```C++ template<typename T = double d> T kwadrat (Td); template<typename T, T int> T kwadrat (Ta); template<typename T = int> T kwadrat (Ta); template<typename T = int i> T kwadrat (Ti); ``` ### Deklaracja X jest ```C++ template<typename T, T par> class klasa; template<typename T, T = par> class klasa; template<class T, T par> class klasa; template<typename T, T = par> struct klasa; ``` ### Definicja X jest ```C++ template<typename T, T par> T kwadrat (T a) { return a*a; } cout << kwadrat<int, 3> (3); cout << kwadrat<double, 3>(3); ``` ### Definicja X jest ```C++ template<typename T1, typename T2 > T1 kwadrat (T2 a) { return a*a; } cout << kwadrat<int>(3); cout << kwadrat (3); cout << kwadrat<int, string>(3); ``` ### Deklaracja X jest ```C++ template<typename T1 int, int iP > class tab; tab<> t1; tab<10> t1; tab<int, 10> t2; ``` ### Podana instrukcja jest ```C++ template class myClass<double>; ``` ### Przedstawiona instrukcja ```C++ Klasa<int> *wskKlasaInt; ``` ### Definicja X ```C++ template<volatile const int &iP> double ilo (double a) { return iP*a; } template<volatile int &iP> double ilo(double a) { return iP*a; } template <const int &iP> double ilo (double a) { return iP*a; } template <const volatile int &iP> double ilo (double a) { return iP*a; } ``` ### Definicja X pozwala na instrukcje: ```C++ struct strKw{ template<typename T> T Kw(Tx){ return x*x; } }; strKw SK; cout << sK.Kw<double>(7.); strKw SK; cout << sK<double>.Kw(7.); strKw<double> sK; cout << SK.Kw(7.); strKw<double> SK; cout << SK.Kw<double>(7.); ``` ### Częściowa spejalizacja szablonu X ```C++ template<typename T, int I> class vect{}; template<int I> class vect<double, I>{}; template<int I> class vect<double, I>{}; template<typename T, int I> class vect<double, I>{}; template<int I> class vect<int*, I>{}; ```