Funkce

O funkcích už leccos víme. Umíme je volat, umíme definovat vlastní funkce, známe speciální funkci main, která se spustí na začátku programu. Přesto je na čase si znalosti prohloubit.

Implementace funkcí

Dobrému programátorovi nestačí jen znalost specifikace jazyka a běžných postupů při programování. Zvlášť v případě Céčka je dobré také vědět, jak funguje přeložený kód a co zhruba odpovídá jednotlivým konstrukcím z C na úrovni asembleru. Tyto znalosti velmi pomáhají v případě nejrůznějších problémů například s pamětí a mohou výrazně urychlit hledání chyby v programu. Vzhledem k množství chyb typu přetečení zásobníku je asi nejdůležitější něco vědět o implementaci funkcí.

Funkce má parametry, vlastní proměnné a návratovou hodnotu. Může být zavolána z libovolného místa v kódu a po skončení běhu funkce program od tohoto místa pokračuje dál, takže je třeba si zapamatovat i adresu, ze které byla funkce zavolána. Funkce může navíc (přímo nebo prostřednictvím jiné funkce) volat i sama sebe, takže v jednom okamžiku může být (i bez použití vláken) rozpracováno více instancí jedné funkce, na procesoru je samozřejmě vždy jen nejvnitřnější instance.

Funkce se běžně implementují pomocí zásobníku. Jedná se o kus paměti, a sadu jednoduchých rutin.

• push data - ulož data na zásobník
• pop - odeber posledně uložená data ze zásobníku
• top - ukazatel na posledně uložená data

případě ještě

• call adresa - současnou adresu ulož na zásobník a skoč na zadanou adresu
• ret - odeber ze zásobníku adresu návratu z funkce a skoč na ni

Na běžných platformách implementuje zásobník přímo hardware a základním rutinám obvykle odpovídá jediná instrukce. Zásobník je přitom přístupný i přes běžné ukazatele.

Parametry, návratová adresa i proměnné funkce se ukládají na zásobník. Před zavoláním funkce se nejprve na zásobník uloží parametry. Začíná se od posledního a končí prvním, důvod se dozvíme v některém z dalších dílů. Následuje instrukce call. Pokud má funkce nějaké proměnné, pomocí push (nebo v praxi obecně změnou hodnoty registru, který ukazuje na vrchol zásobníku) si pro ně vyhradí na zásobníku místo. Funkce vykoná nějaký užitečný kód a má skončit. Pokud má funkce návratovou hodnotu, uloží se obvykle do nějakého registru. Potom uvolní ze zásobníku své lokální proměnné (ne ale parametry) a nakonec zavolá ret. Parametry funkce uvolní až volající kód. Program pak pokračuje v běhu od místa volání funkce dál.

Jednoduchá funkce, která vytiskne int by se do psoudoasembleru přeložila asi takhle.

int printint(int i) {    push [top +- konstanta] /* ulož i */
  printf("%i", i);       push "%i"               /* ulož adresu "%i" */
  return 0;              call printf             /* zavolej printf */
}                        pop                     /* uvolni "%i" */
                         pop                     /* uvolni i */
                         mov registr, 0          /* return 0 */
                         ret                     /* návrat */

Její volání také není obtížné.

printint(10);            push 10                 /* ulož 10 */
                         call printint           /* zavolej printint */
                         pop                     /* uvolni 10 */

Výše uvedený příklad i celé povídání o implementaci funkcí berte trochu s rezervou. V konkrétních případech se může lišit zejména pořadí předávání parametrů a způsob jejich uvolňování, celou věc také komplikují registry procesoru a různé optimalizace. Přesto se základní znalosti o zásobníku a implementaci funkcí mohou programátorovi hodit a to zejména při paměťových chybách nejrůznějšího druhu. Asi nejznámější a nejnebezpečnější je přetečení řetězce definovaného lokálně ve funkci prostřednictvím nějakého vstupu přes Internet. Útočník tak může přepsat na zásobníku adresu pro návrat z funkce na jeho kód, který je součástí tohoto řetězce. Na řadě platforem tedy tato chyba nevede pouze k pádu programu, ale dokonce k vykonání nepřátelského kódu.

Rekurze

Funkce může volat sama sebe, říká se tomu rekurze. Běžně se používá i v matematice, pomocí rekurze se obvykle definuje například faktoriál a lze tak rovněž implementovat v Céčku.

int faktorial(int i) {
  if (i <= 1) return 1;
  return i * faktorial(i - 1);
}

Uvedený postup pochopitelně není příliš efektivní, neboť (jak jsme si ukázali) volání funkce obsahuje určitou režii, která je zde větší než vlastní výpočet faktoriálu pomocí násobení a odčítání jedničky. Mnohem lepší je použít místo rekurze jednoduchý for cyklus.

int faktorial(int i) {
  int j;
  
  if (i <= 1) return 1;
  for (j = i - 1; j >= 2; j--) i *= j;
  return i;
}

Dalším (a vážnějším) problémem rekurze je její paměťová složitost. Při výpočtu faktorial(n) prvním způsobem bude v jednom okamžiku na zásobníku n instancí funkce faktorial, zatímco druhý způsob pracuje v konstantní paměti. V případě rychle rostoucí funkce, jakou je faktoriál, je omezujícím faktorem kapacita proměnné typu int, ale v jiných praktických příkladech často narazíme na omezenou velikost zásobníku. Přesto je rekurze v konkrétních případech běžným programátorským postupem, pouze vždy musíme hlídat maximální hloubku zanoření.

Hlavička funkce

V době překladu není třeba znát implementaci volané funkce. Překladač by však měl znát alespoň jméno funkce a typ parametrů a návratové hodnoty. Zatím jsme proto vždy definovali ve zdrojovém souboru volanou funkci před volající a kód uzavírala funkce main. Toto uspořádání není vždy výhodné a někdy ani není možné. Zdrojový kód může být tvořen více soubory nebo potřebujeme dvě funkce které se vzájemně volají. V tom případě je třeba deklarovat funkci pomocí její hlavičky.

#include <stdio.h>

/* Takhle vypadá deklarace funkce */
void funkceB(int i); 

void funkceA(int i) {
  printf("funkceA, i = %i\n", i);
  if (i <= 0) return;
  /* Zde překladač ještě nezná tělo funkceB, ale to nevadí,
     stačí, že zná hlavičku. */
  funkceB(i - 1);
}

void funkceB(int i) {
  printf("funkceB, i = %i\n", i);
  if (i <= 0) return;
  funkceA(i - 1);
}

int main(void) {
  funkceA(10);
  return 0;
}

Více zdrojových souborů

Pokud se kód programu skládá z více zdrojových souborů s vzájemně se volajícími funkcemi, postupujeme obdobně. Před voláním zajistíme, aby překladač znal hlavičku funkce z druhého souboru.

Při práci na větším projektu hrozí konflikt jmen funkcí. Zde (částečně) pomůže klíčové slovo static. Funkce definovaná jako static je dostupná pouze ze svého zdrojového souboru a nelze ji volat odjinud, ani pokud známe její hlavičku. Taková funkce pak samozřejmě netvoří např. rozhraní knihovny nebo nějakého logického celku v rámci programu, ale je určena pouze pro lokální použití. Při linkování výsledného programu navíc nedojde k chybě, pokud je static funkce stejného jména definovaná i v jiném souboru.

Příklad pro dnešní díl

Ukážeme si první jednoduchý projekt tvořený dvěma zdrojovými soubory. V obou bude definovaná static funkce maximum a po jedné veřejné funkci, které se vzájemně volají.

/* main.c */

#include <stdio.h>

/* hlavička funkce z druhého souboru */
void funkceB(int hloubka);

static int maximum(int i, int j) {
  if (i > j) return i; else return j;
}

void funkceA(int hloubka) {
  puts("funkceA");
  if (hloubka <= 0) return;
  funkceB(hloubka - 1);
}

int main(void) {
  printf("%i\n", maximum(1, 2));
  funkceA(4);
  return 0;
}

A druhý soubor.

/* druhy.c */

#include <stdio.h>

/* hlavička funkce z prvního souboru */
void funkceA(int hloubka);

static double maximum(double i, double j) {
  if (i > j) return i; else return j;
}

void funkceB(int hloubka) {
  puts("funkceB");
  printf("%f\n", maximum(1.1, 2.2));
  if (hloubka <= 0) return;
  funkceA(hloubka - 1);
}

Zkuste nejprve přeložit jen jeden ze souborů příkazem

gcc main.c -o program

Vlastní překlad projde, ale linkování selže na nedefinovaném symbolu funkceB. Nejjednodušším způsobem, jak sestavit program, je překlad a linkování obou zdrojových souborů jediným příkazem.

gcc main.c druhy.c -o program

Náš příklad se od skutečných projektů přece jen v něčem liší. Hlavičky funkcí je lepší umístit do speciálních souborů a projekt překládat pomocí make. Obojí si ukážeme v některém z dalších dílů.

Pokračování příště

V příštím dílu se podíváme podrobněji na proměnné.