Szablony funkcji

Andrzej Walczak

Konspekt wykładu oparty o literaturę z

sylabusu

Czy możliwe jest, aby funkcja była w

pewnym stopniu inteligentna? Czy

mogłaby samodzielnie dobrać zarówno typ

argumentów, jak typ wyniku czyli samej

funkcji?

Tak. Takie zadanie realizuje szablon

funkcji.

Dzięki temu przy korzystanie ze zmiennych

o typach własnych nie następuje mylenie

typów (klas).

Definiowanie szablonu w programie

template

<class

pewien_typ>

pewien_typ

wieksza(pewien_typ a, pewien_typ b)
 
{ return(a>b)?a:b; }

template to słowo kluczowe inicjujące proces tworzenia szablonu

pewien_typ to nazwa szablonu
 
class to słowo kluczowe KONIECZNE aby powstał szablon. Kiedy
parametrów szablonu jest więcej niż jeden, to po przecinku
powtarzamy słowo class i podajemy kolejną nazwę parametru.
 
wieksza to nazwa przykładowej funkcji, która wybiera większą z
dwóch liczb. Typ argumentów i funkcji jest przy tym dowolny,
wbudowany lub zdefiniowany przez programującego. Oznacza to, że
argumentami funkcji mogą być obiekty.

Główne wymagania i cechy

dotyczące szablonu

Główne wymagania i cechy

dotyczące szablonu cd.

•

Operacja zapisana w funkcji poddana jest takim samym regułom
na poprawność operacji jak we wszystkich innych funkcjach ,
czyli nie wykona się na przykład operacja arytmetyczna na
zmiennych znakowych.

•

Parametr szablonu – nazwany jakoś podczas deklarowania
szablonu – nie musi mieć tej samej nazwy podczas definiowania
szablonu.

•

Dwa szablony o takiej samej nazwy mogą wystąpić w tym samym
kodzie. Należy tylko uważać, aby jeden nie był szczególnym
przypadkiem drugiego. Wówczas linker „nie wie” z którego ma
skorzystać.

•

Szablon wstawiając do wzorca funkcji różne typy
argumentów tworzy tak naprawdę przeładowanie funkcji.

•

Sam szablon też może być przeładowany czyli w tym samym
zakresie ważności może wystąpić dwa lub kilka razy z taką samą
nazwą ale różnymi parametrami:

template <class typ> void funkcja (typ, int);

template <class typ> void funkcja (typ, int, float, char);

Główne wymagania i cechy

dotyczące szablonu

cd.

•Szablon jest deklarowany globalnie, ale stosowany lokalnie.
Dlatego nie powinien używać nazw zmiennych globalnych.

•UWAGA: standaryzacja nie obejmuje jeszcze całości szablonów.
Mogą występować kłopoty.

•W szablonie możemy stosować atrybuty inline, extern, static.
Pamiętajmy jednak, że słowo to odnosi się ostatecznie nie do
szablonu ale do funkcji, która wg tego szablonu zostanie zbudowana:

template <class bb>

inline

bb wieksza (bb z1, bb z2)

{ return (z1>z2)? z1:z2; }

Przykład: (wg Grebosza )

#include <iostream>
template <class nasz_typ>
nasz_typ wieksza(nasz_typ a, nasz_typ b)
{ return (a>b)?a:b;}
///////////////////////////////
void main()
{
int a = 44, b = 88;
double x = 14.2, y = 28.4;
unsigned long la = 987654, lb = 777;
// nigdzie nie ma deklaracji konkretnego typu funkcji i typu
argumentów
cout<<”wiekszy int:” <<wieksza(a,b)<<endl;
cout<<”wiekszy double:” <<wieksza(x,y)<<endl;
cout<<”wiekszy long int:” <<wieksza(la,lb)<<endl;
cout<<”wiekszy kod ASCII:” <<wieksza(‘a’,’b’)<<endl;
 
}

Jeśli parametrów jest więcej niż jeden to każdy
musi być poprzedzony słowem class (albo słowem
typename). Jeśli typ parametru się powtarza czyli
są np. dwa parametry typu integer, albo dwa
parametry są obiektami tej samej klasy, to
wymienia się je na liście parametrów tylko raz.
Czyli poprawny jest zapis w kodzie:
////
template <class krakow,class warszawa>
void funkcja_opis_miasta(krakow a, krakow b,
krakow c, warszawa d, warszawa e);
///////

Do argumentu funkcji w szablonie możemy się odwołać przez
referencję.
Referencja była zastosowana do argumentów funkcji wtedy,
kiedy zamierzeniem była zmiana wartości pod adresem
zmiennej.
Teraz przy zdefiniowaniu szablonu możemy ten sam kod
wykorzystać szerzej.
 
#include<iostream>
#include<conio.h>
#include<string.h>
//////////////
 
template<class sejfik>
void zamiana(sejfik &lewy, sejfik &prawy)
{
sejfik pomocniczy;
pomocniczy=lewy;
lewy=prawy;
prawy=pomocniczy;
 
}

///////////////////// teraz wg SZABLONU
void main()
{
float a=-7.0,b=23.0;
 
cout<<”przed zamiana\n”
<<”a=”<<a<<”\tb=”<<b<<endl<<”\n”;
zamiana(a,b);
 
cout<<”po zamianie\n”
<<”a=”<<a<<”\tb=”<<b<<endl<<”\n”;
zamiana(a,b);
 
cout<<”po zamianie ponownej\n”
<<”a=”<<a<<”\tb=”<<b<<endl<<”\n”;

char c=‘A’,d=‘B’;
 
cout<<”przed zamiana\n”
<<”c=”<<c<<”\td=”<<d<<endl<<”\n”;
zamiana(c,d);
 
cout<<”po zamianie\n”
<<”c=”<<c<<”\td=”<<d<<endl<<”\n”;
zamiana(c,d);
 
cout<<”po zamianie ponownej\n”
<<”c=”<<c<<”\td=”<<d<<endl<<”\n”;
 
 
}

#include <iostream>

#include <conio.h>

/////////////////////

template <class nasz_typ>

nasz_typ wieksza(nasz_typ a, nasz_typ b)

{ return (a>b)?a:b;}

//////////////////////

class nowa {public:

double war;

};

Atrybut obiektu argumentem

funkcji szablonowej

void main(){

double aaaa,bbbb;

nowa rr,rrr;

rr.war=10;

rrr.war=1000;

aaaa=rr.war;

bbbb=rrr.war;

int a=44, b=88;

double x=14.2, y=28.4;

unsigned long la=987654, lb=777;

//char A,B;

cout<<"\ntest"<<wieksza(aaaa,bbbb)<<endl; //atrybut obiektu
argumentem szablonu

cout<<endl<<"\n";

getch();}

Funkcje specjalizowane

• template <class parametr1, class

parametr2> parametr1 sumuj (parametr1
argument1, parametr2 argument2) { return
(argument1 + argument2); }

• char * sumuj (char * argument1, char *

argument2)

//funkcja specjalizowana

• { return (*argument1 + *argument2); }