• standardní parametry
• šablony funkcí
• explicitní specializace
• úkol č. 12

Standardní paramatery

Podíváme se blíže na samotné volání f-ce a jeho detaily. Pamatujete si na funkce? Pokud ne, menší připomenutí. Nejvíce nás nyní zajímá samotné volání f-ce.

...
double obsah(double x);		//prototyp f-ce
...
int main();
{
obsah(5);		//volání f-ce
...
return 0;
}

double obsah(double x)	//definice f-ce
{
	return x*x*x;
{

A teď si představte, že hodnotu '5' používáte často. Proč byste ji tedy vždy měli zadávat, resp. proč ji pokaždé nutně zadávat? Existuje vychytávka - standardní parametr. Standardní parametr je hodnota, která bude použita, pokud vynecháte odpovídající skutečný parametr ve volání funkce. Než-li budu cokoliv vysvětlovat, ukážeme si přímo, jak ho použít:

...
double obsah(double x=2);		//změněný prototyp f-ce
...
int main()
{
obsah();		//volání f-ce
...
return 0;
}

double obsah(double x)	//definice f-ce
{
	return x*x*x;
}

Jak jste tedy viděli, jediné, co musíte pro použití standardního parametru udělat, je definovat tento parametr v prototypu f-ce. A nyní si to vysvětlíme. V našem případě bude použita defaultně hodnota '5'. Možná se ptáte, proč byste to měli dělat? Možná vám to přijde zbytečné, zvláště v tomto případě, ale později uznáte, že je to víceméně chytrá věcička, jak si ušetřit čas. Představte si f-ci, která se vás ptá, kolik znaků z nějakého řetězce má vypsat (řetězec má velikost 20 znaků, typ char(char retezec[20])). No pokud chceme vypsat celý řetězec, proč bychom měli zadávat '20'? Vynecháme, a automaticky se hodnota 20 doplní a tím se vypíše celý řetězec. Možná se teď ptáte, co když ale chcete vypsat jen 10 znaků? Tak místo vynechání napíšete '10'. Standardní parametry nám tedy šetří práci.
Viz program napsaný výše: pokud nezadáme při volání f-ce žádné číslo, bude dosazena '2', pokud zadáme, bude dosazena zadaná hodnota. Samozřejmě existují jistá pravidla:

Takto vypadá kód, kdy bude automaticky doplněna hodnota:

#include <iostream>
using namespace std;
double obsah(double x=2); //změněný prototyp f-ce
int main()
{
double s;

s=obsah(); //volání f-ce
cout << s;

cin.get();
cin.get();
return 0;
}

double obsah(double x) //definice f-ce
{
return x*x*x;
}
<*/kod*>
<p>A takto se zadaným parametrem : </p>
<*kod*>
#include <iostream>
using namespace std;
double obsah(double x=2); //změněný prototyp f-ce
int main()
{
double n,s;
cin >> n;
s=obsah(n); //volání f-ce
cout << s;

cin.get();
cin.get();
return 0;
}

double obsah(double x) //definice f-ce
{
return x*x*x;
}

Jestliže použijete f-ci s více parametry, musíte upřednostnit v seznamu obyčejné parametry před standardními, resp. nejdříve vypsat klasické paramtery, poté až standardní. Př.:

int rovnice(int x, int y=4, int z=7);	//ok
int rovnice2(int x, int y=4, int z);	//špatně,int z musí být před int y=4
int rovnice3(int x=1, int y=3, int z=7);	//ok

Volání rovnice tedy může vypadat takto :

vysledek = rovnice(5);		//stejné jako rovnice(5,4,7)
vysledek = rovnice(2,8);	//stejné jako rovnice(2,8,5)
vysledek = rovnice(1,6,3);	//nebyly použity žádné standartní parametry

Přiřazování probíhá zleva doprava, nemůžete je přeskočit. Následující je tedy nepřípustné:

vysledek = rovnice(1, ,9);	//chybně

Šablony funkcí

Předpokládejme, že chcete udělat f-ci, která zaměňuje 2 hodnoty typu int. Jednoduché. Ale co když pak chcete zaměnit 2 hodnoty jiného typu, například double? Máte několik možností:
- vyměnit v programu typy a zkompilovat
- udělat další funkci
- ...

Nepřipadá vám to zbytečné plýtvaní časem? V C++ existují šablony pro f-ce, které nám dávají nové možnosti - například stačí jedna funkce pro záměnu 2 hodnot jakéhokoliv typu. Zajímavé, že? Tak se pojďme podívat, jak na to.

template <typename jmeno_typu>
void nazev_funkce(seznam_parametru)
{
prikazy;
}

První řádek určuje, že jste vytvořili šablonu a jak jste nový typ pojmenovali. Klíčové slova typename a template jsou povinná. Místo typename můžete použít starší "verzi" - class. Sama šablona nevytváří žádné funkce - pouze říká kompilátoru, jak má funkci definovat. Když to řeknu laicky, kompilátor nahradí vámi pojmenovaný typ typem, který je právě potřeba. Nyní si ukážeme šablonu na záměnu oněch 2 hodnot:

template <typename Types>
void vymena(Types &a, Types &b)
{
Types temp;
temp=a;
a=b;
b=temp;
}

A celý program :

#include <iostream>
using namespace std;
// prototyp šablony funkce
template <class Types> // nebo typename Any
void Swap(Types &a, Types &b);

int main()
{
int i = 10;
int j = 20;
cout << "i, j = " << i << ", " << j << ".\n";
cout << "Pouziti prekladacem generovane funkce pro zamenu cisel typu int:\n";
Swap(i,j); // generuje void Swap(int &, int &)
cout << "Nyni i, j = " << i << ", " << j << ".\n";
double x = 24.5;
double y = 81.7;
cout << "x, y = " << x << ", " << y << ".\n";
cout << "Pouziti prekladacem generovane funkce pro zamenu cisel typu double:\n";
Swap(x,y); // generuje void Swap(double &, double &)
cout << "Nyni x, y = " << x << ", " << y << ".\n";
return 0;
}

// definice šablony funkce
template <class Types> // nebo typename Any
void Swap(Types &a, Types &b)
{
Types temp; // temp je proměnná typu Types
temp = a;
a = b;
b = temp;
}

i, j = 10, 20.
Pouziti prekladacem generovane funkce pro zamenu cisel typu int:
Nyni i, j = 20, 10.
x, y = 24.5, 81.7.
Pouziti prekladacem generovane funkce pro zamenu cisel typu double:
Nyni x, y = 81.7, 24.5.

Musíte si uvědomit, že šablony funkcí nedělají vaše programy stručnějšími, kratšími. Výsledný programový kód neobsahuje žádné šablony, obsahuje pouze skutečné funkce. Výhody šablon jsou tedy jednoduchost a spolehlivost.

Explicitní specializace

Slouží ke specializaci při volání. Používají se, pokud definice přesně odpovídá funkčnímu volání.

1. normální funkce ->void show(int n)
2. explicitní specializace -> template<> void vymen(int a, int b)
3. šablonové funkce -> template
4. void swap(Neco a, Neco b)

Kdy se použije co?

...
double u,v;
vymen(u,v);	//použije se 3.
...
int a,b;
vymen(a,b);	//použije se 2. => specializace na int

#include <iostream>
using namespace std;
template <class Any>
void Swap(Any &a, Any &b);

struct job
{
char name[40];
double salary;
int floor;
};

// explicitní specializace
template <> void Swap<job>(job &j1, job &j2);
void Show(job &j);

int main()
{
cout.precision(2);
cout.setf(ios::fixed, ios::floatfield);
int i = 10, j = 20;
cout << "i, j = " << i << ", " << j << ".\n";
cout << "Pouziti prekladacem generovane funkce pro zamenu cisel typu int:\n";
Swap(i, j); // generuje void Swap(int &, int &)
cout << "Nyni i, j = " << i << ", " << j << ".\n";

job sue = {"Susan Yaffee", 63000.60, 7};
job sidney = {"Sidney Taffee", 66060.72, 9};
cout << "Pred zamenou obsahu struktur job:\n";
Show(sue);
Show(sidney);
Swap(sue, sidney); // používá void Swap(job &, job &)
cout << "Po zamene obsahu struktur job:\n";
Show(sue);
Show(sidney);

return 0;
}

template <class Any>
void Swap(Any &a, Any &b) // obecná verze
{
Any temp;
temp = a;
a = b;
b = temp;
}

// zaměňuje pouze pole salary a floor struktury job

template <> void Swap<job>(job &j1, job &j2) // specializace
{
double t1;
int t2;
t1 = j1.salary;
j1.salary = j2.salary;
j2.salary = t1;
t2 = j1.floor;
j1.floor = j2.floor;
j2.floor = t2;
}

void Show(job &j)
{
cout << j.name << ": " << j.salary
<< " Kc na poschodi " << j.floor << "\n";
}

i, j = 10, 20.
Pouziti prekladacem generovane funkce pro zamenu cisel typu int:
Nyni i, j = 20, 10.
Pred zamenou obsahu struktur job:
Susan Yaffee: 63000.60 Kc na poschodi 7
Sidney Taffee: 66060.72 Kc na poschodi 9
Po zamene obsahu struktur job:
Susan Yaffee: 66060.72 Kc na poschodi 9
Sidney Taffee: 63000.60 Kc na poschodi 7

Když použijete explicitní specializaci, kompilátor zjistí specializovanou definici, která přesně odpovídá funkčnímu volání, použije ji, aniž by se podíval na šablony.

Úkol č.12

Napište program, který zamění 2 hodnoty (pomocí funkce a šablon) jakéhokoliv typu. Tedy, uživatel zadá 2 hodnoty a ty se poté ve výpisu prohodí.