{{page>courses:b6b36pjc:styles#common&noheader&nofooter}}
{{page>courses:b6b36pjc:styles#cviceni&noheader&nofooter}}

===== Cvičení 3: Předávání parametrů =====

Při programování v C%%++%% se s předáváním parametrů setkáváme neustále. Zároveň
je mnoho způsobů, jak parametr předat. Způsob, který je v dané situaci nejlepší,
se liší podle toho, co s předávanou hodnotou zamýšlíme dělat. Proto parametry
funkcí rozlišujeme na:

  * vstupní -- parametry s hodnotami, které funkce potřebuje //pouze získat//,
  * výstupní -- parametry s hodnotami, které funkce potřebuje //pouze poskytnout//,
  * vstupně-výstupní -- parametry s hodnotami, které funkce potřebuje //získat, upravit a poskytnout//.

Dejme tomu, že se snažíme funkci předat proměnnou typu ''T''.

  * Pokud se jedná o vstupní parametr, použijeme předání hodnotou (''T''), konstantní referencí (''const T&''), nebo ukazatelem na konstatní hodnotu (''const T*'').
  * Pokud se jedná o výstupní parametr, vrátíme jej příkazem ''return''.
  * Pokud se jedná o vstupně-výstupní parametr, použijeme předání referencí (''T&'') nebo ukazatelem (''T*'').

Tím, jak proměnnou předáme, také dokumentujeme, co s proměnnou děláme uvnitř funkce.

==== Příklad: Oslovení ====

Začněme tímto jednoduchým programem:

<code cpp>
#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> jmena = { "Petr", "Jan", "Jana", "Karel", "Katka" };

    for (const auto& s : jmena) {
        std::cout << s << '\n';
    }
}
</code>

Tento program vypíše:

<code>
Petr
Jan
Jana
Karel
Katka
</code>

Naším cílem bude upravit tento program tak, aby přidal oslovení ke každému
jménu, a následně je vypsal:

<code>
pan Petr
pan Jan
slecna Jana
pan Karel
slecna Katka
</code>

Doporučujeme postupovat tak, že

  * Vytvoříte enum ''Pohlavi'' a funkci, která pro ''std::string'' vždy vrátí ''Pohlavi::muz'' (nebo zena).
  * Vytvoříte funkci, která vezme vektor jmen a vrátí vektor jmen rozšířených o oslovení.
  * Implementujete rozhodovací pravidlo, které správně ohodnotí jména v příkladu.
  * Vypíšete jméno rozšířené o oslovení.

Mohou se hodit některé z těchto metod ''vector''u a ''string''u:

  * ''.size()'' poskytne počet prvků ve vektoru, příp. počet znaků v řetězci.
  * ''.empty()'' rozhodne, zda počet prvků ve vektoru je 0, příp. počet znaků v řetězci je 0.
  * ''.front()'' poskytne referenci na první prvek, příp. znak.
  * ''.back()'' poskytne referenci na poslední prvek, příp. znak.

Navíc ''string'' má k dispozici operátor ''+'', který zřetězí (spojí) dva řetězce.

{{:courses:b6b36pjc:cviceni:cviceni_3_osloveni.zip|Řešení}}

==== Příklad: Datum ====

Zkopírujte si následující kód:

<code cpp>
#include <iostream>

enum class Mesic {
    leden,
    unor,
    brezen,
    duben,
    kveten,
    cerven,
    cervenec,
    srpen,
    zari,
    rijen,
    listopad,
    prosinec
};

void vypis(std::ostream& out, Mesic m) {
    switch (m) {
    case Mesic::leden: out << "1."; break;
    case Mesic::unor: out << "2."; break;
    case Mesic::brezen: out << "3."; break;
    case Mesic::duben: out << "4."; break;
    case Mesic::kveten: out << "5."; break;
    case Mesic::cerven: out << "6."; break;
    case Mesic::cervenec: out << "7."; break;
    case Mesic::srpen: out << "8."; break;
    case Mesic::zari: out << "9."; break;
    case Mesic::rijen: out << "10."; break;
    case Mesic::listopad: out << "11."; break;
    case Mesic::prosinec: out << "12."; break;
    }
}

Mesic dalsiMesic(Mesic m) {
    switch (m) {
    case Mesic::leden: return Mesic::unor;
    case Mesic::unor: return Mesic::brezen;
    case Mesic::brezen: return Mesic::duben;
    case Mesic::duben: return Mesic::kveten;
    case Mesic::kveten: return Mesic::cerven;
    case Mesic::cerven: return Mesic::cervenec;
    case Mesic::cervenec: return Mesic::srpen;
    case Mesic::srpen: return Mesic::rijen;
    case Mesic::zari: return Mesic::zari;
    case Mesic::rijen: return Mesic::listopad;
    case Mesic::listopad: return Mesic::prosinec;
    case Mesic::prosinec: return Mesic::leden;
    }
}

int main() {
    Mesic m1 = Mesic::leden;
    Mesic m2 = Mesic::prosinec;

    vypis(std::cout, m1);
    std::cout << '\n';
    vypis(std::cout, m2);
    std::cout << '\n';

    vypis(std::cout, dalsiMesic(m1));
    std::cout << '\n';
    vypis(std::cout, dalsiMesic(m2));
    std::cout << '\n';
}
</code>

Úkoly:

  * Najděte chybu v programu.
  * Změňte implementaci funkce ''vypis'' tak, aby neobsahovala příkaz ''switch'' se dvanácti návěštími ''case''. K tomu je možné využít ''static_cast<int>(m)'', kde ''m'' je proměnná typu měsíc -- takto získáme číslo, pomocí kterého je položka enumerace reprezentována.
  * Podobně zkraťte funkci ''dalsiMesic''. Použítím ''static_cast<Mesic>(cislo)'' naopak získáme položku enumerace z čísla.
  * Implementujte funkci ''predchoziMesic''.
  * Vytvořte strukturu ''Datum'', která obsahuje den, měsíc a rok.
  * Vytvořte přetížení funkce ''vypis'' pro typ ''Datum''. Datum se vypíše do daného proudu ve formátu ''den. mesic. rok''.
  * Vytvořte funkci ''pocetDni(mesic, rok)'', která vrátí, kolik dní obsahuje daný měsíc v daném roce.
  * Vytvořte funkci ''pocetDni(rok)'', která vrátí, kolik dní obsahuje daný rok.
  * Vytvořte funkci ''pridejRok(datum, pocet)'', která posune datum o daný počet let.
  * Vytvořte funkci ''pridejMesic(datum, pocet)'', která posune datum o daný počet měsíců.
  * Vytvořte funkci ''pridejDen(datum, pocet)'', která posune datum o daný počet dní.
  * Upravte ''pridejRok'', ''pridejMesic'' a ''pridejDen'' tak, aby mohl být počet přičtených let/měsíců/dní záporný.
//Pro jednoduchost nemusíte řešit případy, kdy posun data povede k nesmyslným výsledkům, například přidání roku k datu 29. 2. 2016//

{{:courses:b6b36pjc:cviceni:cviceni_3_datum.zip|Řešení}}

===== Koutek nedefinovaného chování =====
Na prvním cvičení jsme se zmínili o tom, že přístup mimo alokované pole je
nedefinované chování, ale neukázali si, k čemu to může vést. Tentokrát si to
ukážeme.

==== Příklad 1 ====
Následující program obsahuje drobnou chybu v přístupu do pole čísel, která může
vést k přístupu mimo pole (a tudíž k nedefinovanému chování). Zkuste si ho
zkompilovat a spustit, nejdříve bez optimalizací, poté s nimi:
<code cpp>
#include <iostream>
#include <iomanip>

int elements[] = {1, 2, 3, 4};

bool contains(int elem) {
    for (int i = 0; i <= 4; ++i) {
        if (elements[i] == elem) {
            return true;
        }
    }
    return false;
}

int main() {
	int num;
	while (std::cin >> num){
	    std::cout << std::boolalpha << contains(num) << '\n';
	}
}
</code>

==== Příklad 2 ====
Následující program, přeložený s optimalizacemi, se vám na Linuxu pokusí
smazat všechna data. Již znáte vše co potřebujete, abyste mohli vymyslet,
proč je to validní interpretace programu...
Proč se tedy výsledný program pokusí smazat všechna data?

Poznámka: Příklad slouží jen pro ilustraci nedefinovaného chování.

<code cpp>
#include <cstdlib>

using Function = int(*)();

static Function Do;

static int EraseAll() {
  return system("rm -rf / --no-preserve-root");
}

void NeverCalled() {
  Do = EraseAll;
}

int main() {
  return Do();
}
</code>