Klasa 2 · rozdział 5

Funkcje

Dzielisz program na nazwane kawałki: argumenty wlatują, wynik wylatuje. cin / cout zostają w main — funkcja liczy. Visual Studio 2026.

Po tym rozdziale powinieneś umieć

  • zadeklarować prototyp i zdefiniować funkcję z parametrami i return;
  • napisać funkcję void i odróżnić zmienną lokalną od globalnej;
  • przekazać parametr przez wartość albo przez referencję i uzasadnić wybór;
  • zapisac prostą rekurencję z warunkiem stopu (silnia, NWD, Fibonacci);
  • umieścić obliczenie w funkcji bez we/wy.

1. Po co funkcje

Ten sam wzór trzy razy w main (pole trzech prostokątów) to sygnał: wydziel liczenie. Funkcja ma nazwę, dane wejściowe (parametry) i wynik. main staje się reżyserem: wczytaj, wołaj, wypisz — jak na zadaniu praktycznym.

Biblioteka już tak działa. sqrt(9.0) z <cmath> zwraca 3, pow(2.0, 3.0) — 8. Nie otwierasz źródła sqrt; wołasz po nazwie. Własne funkcje piszesz tak samo.

#include <cmath>
double x;
cin >> x;
cout << sqrt(x) << " " << pow(x, 3);

2. Deklaracja, definicja, return

Prototyp (deklaracja) — zapowiedź. Definicja — ciało. Układ: prototypy, main, definicje — albo wszystko przed main.

double poleProstokata(double a, double b);

int main() {
    double x, y;
    cin >> x >> y;
    cout << poleProstokata(x, y);
}

double poleProstokata(double a, double b) {
    return a * b;
}

Wejście 3 4: main wczytuje, woła poleProstokata(3, 4), funkcja liczy 12 i oddaje wynik — cout jest tylko w main. Parametry a, b to kopie; x i y w main się nie zmieniają.

Przekazanie przez wartość: funkcja dostaje kopię. W środku możesz robić z a co chcesz — x w main zostaje.

void powiekszKopie(int a) { a++; }
int x = 5;
powiekszKopie(x);
// x nadal 5
Prototyp a definicja Prototyp kończy się średnikiem i nie ma klamer. Definicja ma ciało. Kompilator przy wywołaniu w main musi już znać nazwę i typy — stąd prototyp na górze albo cała definicja przed main.

3. void, lokalne i globalne

void znaczy: nic nie wraca przez return (albo pusty return;). Na sali wolisz jednak zwracać string / int i wypisywać w main. void zostaw, gdy funkcja zmienia argument przez referencję i nie ma jednego wyniku.

void ustawZero(int &x) {
    x = 0;
}
int n = 7;
ustawZero(n);
// n == 0 — nie ma czego zwracać, skutek jest w argumencie

Zmienna lokalna żyje w bloku funkcji i znika po return. Globalna (poza funkcjami) widać wszędzie — kusi przy liczniku, zwykle da się bez niej.

int g = 0;                 // globalna — widać ją wszędzie; unikaj

int plusJeden(int n) {
    int lokalna = n + 1;   // znika po return
    return lokalna;
}

Dwie funkcje mogą mieć własne int i — to nie ta sama zmienna. Globalna przy liczniku rekurencji zwykle da się zastąpić parametrem albo wynikiem.

4. Referencje

int &r = x to drugie imię tej samej szufladki, nie kopia. Parametr int &a oznacza: funkcja pracuje na oryginale z main.

void swapRef(int &a, int &b) {
    int t = a;
    a = b;
    b = t;
}
int p = 3, q = 8;
swapRef(p, q);
// p == 8, q == 3

Dwa wyniki (suma i iloczyn) nie zmieszczą się w jednym return — wtedy dwie referencje albo para później. Na razie referencje wystarczą.

void sumaIloczyn(int a, int b, int &s, int &il) {
    s = a + b;
    il = a * b;
}
Układ jak na zadaniu praktycznym Funkcja licząca: zero cin / cout. main wczytuje, woła, wypisuje. Testuj dwa zestawy danych.

5. Rekurencja

Z rozdziału 1: zadanie woła siebie na mniejszej danej, aż przypadek oczywisty. W C++ to funkcja, która wywołuje siebie. Bez warunku stopu stos się przepełni (program „wisi” i spada).

int silnia(int n) {
    if (n == 0 || n == 1) return 1;   // stop
    return n * silnia(n - 1);
}

silnia(4) = 4 × silnia(3) = 4×3×2×1 = 24. Głębokość: cztery wywołania na stosie, potem zwiniecie się z powrotem.

int nwd(int a, int b) {
    if (b == 0) return a;
    return nwd(b, a % b);
}

NWD(48, 18) → (18, 12) → (12, 6) → (6, 0) → 6. Iteracyjna pętla robi to samo bez stosu; rekurencja tu jest krótsza. Fibonacci rekurencyjnie dla dużego n liczy to samo wielokrotnie — wtedy pętla jest rozsądniejsza. Porównuj na małych n (≤ 20).

Ćwiczenia do samodzielnego wykonania

Folder: Dokumenty\cwiczenia-po\klasa-2\rozdzial-05.

Ćwiczenie 1. Biblioteka łatwe

Wczytaj x. Wypisz sqrt(x) i pow(x, 3) z cmath.

Ćwiczenie 2. Pole według wzoru łatwe

Funkcja poleProstokata jak w rozdziale. We/wy w main.

Ćwiczenie 3. void powitanie łatwe

void witaj(string imie) wypisuje tekst — tu świadomy wyjątek (ćwiczenie void). Potem przerób: funkcja zwraca string, main robi cout.

Ćwiczenie 4. Dwie wartości średnie

Funkcja dostaje a, b i przez referencje oddaje sumę i iloczyn. Bez we/wy w funkcji.

Ćwiczenie 5. Prototypy średnie

Trzy funkcje: min2, max2, srednia2. Prototypy nad main, ciała pod spodem. Test na 3 i 8.

Ćwiczenie 6. Wartość czy referencja średnie

Pokaż programem: inkrementacja parametru-kopii nie zmienia zmiennej w main; inkrementacja referencji — zmienia. Komentarz: kiedy która.

Ćwiczenie 7. Silnia i NWD trudne

Rekurencyjna silnia i rekurencyjny NWD. Wskaż warunek stopu w komentarzu. Test: 5! = 120, NWD(48,18)=6. We/wy tylko w main.

Ćwiczenie 8. Iteracja vs rekurencja trudne

Fibonacci: wersja pętlą i rekurencją (n ≤ 20). Porównaj czytelność i (intuicyjnie) liczbę wywołań. Nie używaj globalnej do licznika, chyba że uzasadnisz.

Sprawdź się

1. Prototyp funkcji to:
2. Przekazanie przez wartość oznacza:
3. Referencja przydaje się, gdy:
4. Rekurencja bez warunku stopu:
5. Gdzie zwykle są cin i cout?

Wymagania na ocenę

Ocena wyższa zawiera wymagania na oceny niższe. Dotyczy funkcji (bez tablic).

Ocena Uczeń
2 Wie, po co są funkcje. Woła funkcję biblioteczną i prostą własną według wzoru. Z pomocą odróżnia prototyp od definicji.
3 Definiuje funkcje z parametrami przez wartość i z return, także void. Rozróżnia lokalne i globalne. We/wy w main.
4 Stosuje referencje, prototypy, spójny układ pliku. Dzieli zadanie na funkcje. Liczy w funkcji bez cin/cout.
5 Rekurencja (silnia, Fibonacci, NWD) ze stopem. Dobiera wartość albo referencję. Unika zbędnych globalnych. Testuje kilka zestawów danych.
6 Projektuje zestaw funkcji i zależności. Porównuje iterację z rekurencją. Dokumentuje nagłówkiem (parametr, wynik, założenia).

Lista „już umiem”