C++ · Podstawy · Funkcje

Funkcje w C++

Nazwany kawałek kodu, który możesz uruchomić, kiedy chcesz. Zamiast kopiować ten sam fragment pięć razy — napisz go raz i wywołuj po nazwie.

Filmy z OKI

Wolisz obejrzeć?

Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 2 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.

Materiały Olimpijskiego Koła Informatycznego — kanał zewnętrzny. Kliknięcie odtwarza film tutaj, bez opuszczania strony.

Po co komu funkcja?

Wyobraź sobie, że w trzech miejscach programu musisz policzyć pole prostokąta. Możesz trzy razy przepisać ten sam wzór — a potem trzy razy go poprawiać, gdy okaże się, że coś było nie tak. Funkcja pozwala napisać ten kawałek raz i używać go po nazwie, ile razy chcesz.

Jedną funkcję już zresztą piszesz w każdym programie: main. Twoje własne będą wyglądać dokładnie tak samo — różnią się tylko nazwą i tym, co robią.

bez_funkcji.cpp
int main() {
    // ten sam wzor trzy razy
    cout << 3 * 4 << "\n";
    cout << 5 * 2 << "\n";
    cout << 7 * 6 << "\n";

    return 0;
}
▶ Wyjście programu
12 10 42
z_funkcja.cpp
// napisane raz
int pole(int a, int b) {
    return a * b;
}

int main() {
    cout << pole(3, 4) << "\n";
    cout << pole(5, 2) << "\n";
    cout << pole(7, 6) << "\n";

    return 0;
}
▶ Wyjście programu
12 10 42

Przy trzech mnożeniach różnica jest mała. Ale gdy funkcja ma dziesięć linijek i używasz jej w pięciu miejscach, oszczędzasz czterdzieści linijek i masz jedno miejsce do poprawiania, gdy coś nie działa.

📤

typ zwracany

Co funkcja oddaje na końcu: int, double, string. Gdy nic nie oddaje — void.

🏷️

nazwa

Wymyślasz ją sam. Najlepiej czasownik albo rzeczownik mówiący, co dostaniesz: pole, wypiszWynik.

📥

parametry

To, co funkcja dostaje do pracy, w nawiasie. Każdy z własnym typem: (int a, int b). Może ich nie być wcale.

📦

ciało w klamrach

Kod, który się wykona. Zmienne utworzone w środku znikają po zakończeniu funkcji.

↩️

return

Oddaje wynik i natychmiast kończy funkcję. Kod poniżej się nie wykona.

⬆️

kolejność w pliku

Funkcję pisz powyżej main. Inaczej kompilator jej nie zna, gdy trafi na wywołanie.

skladnia.cpp
#include <iostream>
using namespace std;

//  typ   nazwa  parametry
    int   pole  (int a, int b) {
        return a * b;          // oddaje wynik
    }

int main() {
    int wynik = pole(3, 4);    // wywolanie
    cout << wynik << "\n";

    // mozna tez od razu w cout
    cout << pole(10, 10);

    return 0;
}
▶ Wyjście programu
12 100

Zwróć uwagę na dwa słowa, które łatwo pomylić. Definicja to napisanie funkcji — z klamrami i ciałem. Wywołanie to jej użycie: pole(3, 4). Definiujesz raz, wywołujesz ile chcesz.

Funkcje, które coś oddają — i te, które nie

Nie każda funkcja musi coś zwracać. Czasem chcesz tylko, żeby coś zrobiła: wypisała wynik, narysowała ramkę, pokazała menu. Wtedy jako typ podajesz void, czyli „nic”.

zwraca.cpp
// oddaje liczbe - mozna ja zapamietac
int wiekszy(int a, int b) {
    if (a > b) return a;
    return b;
}

int main() {
    int x = wiekszy(7, 3);
    cout << x;
    return 0;
}
▶ Wyjście programu
7
nic_nie_zwraca.cpp
// nic nie oddaje - tylko dziala
void ramka(string tekst) {
    cout << "+------------+\n";
    cout << "| " << tekst << " |\n";
    cout << "+------------+\n";
}

int main() {
    ramka("Czesc!");
    return 0;
}
▶ Wyjście programu
+------------+ | Czesc! | +------------+

return robi dwie rzeczy naraz: oddaje wartość i natychmiast kończy funkcję. Wszystko, co stoi poniżej, już się nie wykona. To bardzo przydatne — pozwala wyjść wcześniej, gdy odpowiedź jest już znana.

wczesne_wyjscie.cpp
#include <iostream>
using namespace std;

bool czyParzysta(int x) {
    if (x % 2 == 0) {
        return true;          // konczymy tutaj
    }
    return false;             // tu dojdziemy tylko dla nieparzystych
}

// w funkcji void tez mozna wyjsc wczesniej
void sprawdz(int wiek) {
    if (wiek < 0) {
        cout << "Bledny wiek\n";
        return;               // samo return, bez wartosci
    }
    cout << "Wiek: " << wiek << "\n";
}

int main() {
    cout << czyParzysta(8) << "\n";
    sprawdz(-5);
    sprawdz(14);
    return 0;
}
▶ Wyjście programu
1 Bledny wiek Wiek: 14

Uwaga na jedną rzecz: jeśli funkcja ma typ inny niż void, to każda droga przez jej ciało musi kończyć się return. Gdy zapomnisz o jednej gałęzi if-a, kompilator zwykle ostrzeże, a program zwróci przypadkową wartość.

Kopia czy oryginał?

Domyślnie funkcja dostaje kopię tego, co jej podasz. Zmiana wewnątrz funkcji nie dotyka oryginału — tak samo jak przy krótkiej pętli for (int x : v) z tematu o wektorach. Żeby pracować na oryginale, dopisujesz ampersand przy parametrze.

kopia.cpp
// bez & - funkcja dostaje kopie
void podwoj(int x) {
    x = x * 2;
    cout << "w srodku: " << x << "\n";
}

int main() {
    int a = 5;
    podwoj(a);
    cout << "po wyjsciu: " << a;
    return 0;
}
▶ Wyjście programu
w srodku: 10 po wyjsciu: 5
oryginal.cpp
// z & - funkcja dostaje oryginal
void podwoj(int& x) {
    x = x * 2;
    cout << "w srodku: " << x << "\n";
}

int main() {
    int a = 5;
    podwoj(a);
    cout << "po wyjsciu: " << a;
    return 0;
}
▶ Wyjście programu
w srodku: 10 po wyjsciu: 10

Jeden znak, a zupełnie inny wynik. Kiedy używać którego? Bez ampersanda, gdy funkcja ma tylko coś policzyć i oddać przez return. Z ampersandem, gdy ma zmienić to, co dostała — albo gdy dostaje duży wektor i kopiowanie byłoby marnotrawstwem.

Dla dużych danych jest jeszcze trzecia możliwość: const vector<int>& v. Ampersand oznacza „nie kopiuj”, a const — „i nie zmieniaj”. To najlepszy wybór, gdy funkcja tylko czyta duży wektor.

trzy_sposoby.cpp
#include <iostream>
#include <vector>
using namespace std;

// tylko czyta - nie kopiuje, nie zmienia
int suma(const vector<int>& v) {
    int s = 0;
    for (int x : v) s += x;
    return s;
}

// zmienia oryginal
void wyzeruj(vector<int>& v) {
    for (int& x : v) x = 0;
}

int main() {
    vector<int> v = {1, 2, 3, 4};

    cout << suma(v) << "\n";      // 10
    wyzeruj(v);
    cout << suma(v) << "\n";      // 0

    return 0;
}
▶ Wyjście programu
10 0

Funkcja, która wywołuje samą siebie

Na koniec jedna rzecz, którą funkcje potrafią, a która zaskakuje wszystkich przy pierwszym spotkaniu: funkcja może wywołać samą siebie. Brzmi jak błąd, ale to sposób na problemy, które naturalnie dzielą się na mniejsze kopie samych siebie.

rekurencja.cpp
#include <iostream>
using namespace std;

long long silnia(int n) {
    if (n <= 1) return 1;        // warunek stopu
    return n * silnia(n - 1);    // krok w dol
}

int main() {
    cout << silnia(5);
    return 0;
}
▶ Wyjście programu
120

Działa to tak: silnia(5) nie zna odpowiedzi, więc pyta silnia(4), ta pyta silnia(3) i tak dalej, aż do silnia(1), które zna odpowiedź od ręki. Wtedy wyniki wracają w górę.

Każda taka funkcja musi mieć warunek stopu — sytuację, w której przestaje wołać siebie. Bez niego program wysypie się w ułamku sekundy. Rekurencja ma jednak znacznie więcej niuansów, niż mieści się w jednej sekcji, więc poświęcamy jej osobny temat — następny w kolejności. Tam znajdziesz stos wywołań, śledzenie krok po kroku i to, kiedy rekurencja naprawdę się opłaca, a kiedy lepiej wziąć zwykłą pętlę.

Wszystkie sposoby pisania funkcji

Dziesięć zapisów, które pokrywają wszystko, co będziesz robić z funkcjami przez najbliższe miesiące.

ZapisCo znaczyKiedy tego użyjesz
int f(int a) Dostaje kopię, oddaje liczbę. Domyślny wybór dla obliczeń
void f(int a) Nic nie oddaje, tylko działa. Wypisywanie, rysowanie
int f() Bez parametrów. Gdy funkcja nic nie potrzebuje
void f(int& a) Dostaje oryginał — może go zmienić. Gdy funkcja ma coś poprawić
int f(const vector<int>& v) Nie kopiuje i nie zmienia. Duże dane tylko do odczytu
int f(int a, int b = 10) Drugi parametr ma wartość domyślną. Można wywołać f(5)
return wartosc; Oddaje wynik i kończy funkcję. —
return; Kończy funkcję void bez wartości. Wcześniejsze wyjście
f(n - 1) Wywołanie samej siebie. Rekurencja — pamiętaj o warunku stopu
int f(int); Sam nagłówek ze średnikiem. Gdy chcesz definicję poniżej main

Zwróć uwagę na wiersz czwarty i piąty — cała różnica to jeden znak &. Bez niego funkcja dostaje kopię i zmiany przepadają; z nim pracuje na oryginale. To źródło większości zdziwień przy funkcjach.

Sprawdź się na zadaniach

Sześć zadań od najprostszego. Pierwsze trzy to zwykłe funkcje liczące, dalsze dotykają referencji i rekurencji. Najpierw spróbuj sam.

Łatwe Funkcja licząca pole
Napisz funkcję pole(a, b), która zwraca pole prostokąta, i funkcję obwod(a, b), która zwraca jego obwód. Wczytaj boki i wypisz oba wyniki.
Jak to ugryźć: Obie funkcje mają typ int, dwa parametry i jedną linijkę ciała. Pamiętaj, żeby napisać je powyżej main.
Pokaż rozwiązanie
prostokat.cpp
#include <iostream>
using namespace std;

int pole(int a, int b) {
    return a * b;
}

int obwod(int a, int b) {
    return 2 * (a + b);
}

int main() {
    int a, b;
    cin >> a >> b;

    cout << "Pole:  " << pole(a, b) << "\n";
    cout << "Obwod: " << obwod(a, b) << "\n";

    return 0;
}
Łatwe Czy liczba pierwsza
Napisz funkcję czyPierwsza(n) zwracającą bool. Wczytaj n liczb i dla każdej wypisz TAK albo NIE.
Jak to ugryźć: Liczba pierwsza dzieli się tylko przez 1 i samą siebie. Sprawdź w pętli, czy cokolwiek między 2 a n-1 dzieli ją bez reszty — jeśli tak, od razu return false. Pamiętaj, że 0 i 1 nie są pierwsze.
Pokaż rozwiązanie
pierwsza.cpp
#include <iostream>
using namespace std;

bool czyPierwsza(int n) {
    if (n < 2) return false;

    for (int i = 2; i < n; i++) {
        if (n % i == 0) return false;   // znalazlem dzielnik
    }

    return true;
}

int main() {
    int ile;
    cin >> ile;

    for (int i = 0; i < ile; i++) {
        int x;
        cin >> x;
        cout << (czyPierwsza(x) ? "TAK" : "NIE") << "\n";
    }

    return 0;
}
Łatwe Ramka wokół tekstu
Napisz funkcję void ramka(string s), która wypisuje podany tekst otoczony ramką z gwiazdek dopasowaną do jego długości.
Jak to ugryźć: Funkcja nic nie zwraca, więc jej typ to void. Górna i dolna linia ma tyle gwiazdek, ile znaków ma tekst plus 4 — wypiszesz je pętlą.
Pokaż rozwiązanie
ramka.cpp
#include <iostream>
#include <string>
using namespace std;

void ramka(string s) {
    int szerokosc = s.length() + 4;

    for (int i = 0; i < szerokosc; i++) cout << "*";
    cout << "\n";

    cout << "* " << s << " *\n";

    for (int i = 0; i < szerokosc; i++) cout << "*";
    cout << "\n";
}

int main() {
    string s;
    getline(cin, s);

    ramka(s);
    return 0;
}
Średnie Zamień dwie liczby
Napisz funkcję zamien(a, b), która zamienia miejscami wartości dwóch zmiennych w miejscu wywołania. Po jej użyciu w main zmienne mają być zamienione.
Jak to ugryźć: Bez ampersanda funkcja dostanie kopie i nic się nie zmieni. Oba parametry muszą być int&. W środku potrzebna jest trzecia zmienna pomocnicza — tak jak przy przelewaniu wody między szklankami.
Pokaż rozwiązanie
zamien.cpp
#include <iostream>
using namespace std;

void zamien(int& a, int& b) {
    int pomocnicza = a;
    a = b;
    b = pomocnicza;
}

int main() {
    int x = 3, y = 8;

    cout << "Przed: " << x << " " << y << "\n";
    zamien(x, y);
    cout << "Po:    " << x << " " << y << "\n";

    return 0;
}
Średnie Największy wspólny dzielnik
Napisz funkcję nwd(a, b) zwracającą największy wspólny dzielnik dwóch liczb. Wczytaj dwie liczby i wypisz wynik.
Jak to ugryźć: Prosty sposób: sprawdzaj po kolei liczby od mniejszej z dwóch w dół i zwróć pierwszą, która dzieli obie bez reszty. Krótsza wersja rekurencyjna korzysta z faktu, że nwd(a, b) to to samo co nwd(b, a % b), a nwd(a, 0) to a.
Pokaż rozwiązanie
nwd.cpp
#include <iostream>
using namespace std;

// wersja rekurencyjna - trzy linijki
int nwd(int a, int b) {
    if (b == 0) return a;        // warunek stopu
    return nwd(b, a % b);
}

int main() {
    int a, b;
    cin >> a >> b;

    cout << nwd(a, b);
    return 0;
}
Trudne Fibonacci: pętla kontra rekurencja
Ciąg Fibonacciego zaczyna się od 0, 1, a każdy kolejny wyraz to suma dwóch poprzednich. Napisz obie wersje funkcji — rekurencyjną i z pętlą — i policz fib(40) każdą z nich.
Jak to ugryźć: Wersja rekurencyjna jest krótsza i ładniejsza, ale dla n = 40 wykona ponad miliard wywołań, bo liczy te same rzeczy w kółko. Wersja z pętlą policzy to samo w 40 krokach. To najlepsza ilustracja tego, że rekurencja nie zawsze jest dobrym pomysłem.
Pokaż rozwiązanie
fibonacci.cpp
#include <iostream>
using namespace std;

// krotka, ale bardzo wolna dla duzych n
long long fibRek(int n) {
    if (n <= 1) return n;
    return fibRek(n - 1) + fibRek(n - 2);
}

// dluzsza, ale blyskawiczna
long long fibPetla(int n) {
    if (n <= 1) return n;

    long long a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        long long c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    cout << fibPetla(40) << "\n";   // natychmiast
    cout << fibRek(40) << "\n";     // kilka sekund!

    return 0;
}

Częste błędy i dobre praktyki

⬆️
Funkcja przed main
Kompilator czyta plik od góry. Gdy wywołujesz funkcję zdefiniowaną niżej, zgłosi błąd o nieznanej nazwie — po prostu przesuń ją wyżej.
↩️
return kończy funkcję
Kod poniżej return nigdy się nie wykona. To nie błąd, tylko sposób na wcześniejsze wyjście.
❗
Każda ścieżka musi mieć return
Jeśli funkcja ma typ inny niż void, to każda gałąź if-a musi kończyć się return. Inaczej dostaniesz przypadkową wartość.
🔗
Ampersand zmienia oryginał
void f(int& x) pracuje na oryginale, void f(int x) na kopii. Jeden znak, zupełnie inny efekt.
📦
Duże dane przez const&
const vector<int>& v nie kopiuje i nie pozwala zmieniać. Najlepszy wybór, gdy funkcja tylko czyta.
🔄
Rekurencja bez warunku stopu
Funkcja, która zawsze woła samą siebie, wysypie program w ułamku sekundy. Warunek stopu pisz jako pierwszą linijkę.

Gotowy na więcej?

Dołącz do T-Olimpians i trenuj z doświadczonymi mentorami. Zbuduj bazę, która prowadzi do finałów OI.