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ć.
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ą.
int main() {
// ten sam wzor trzy razy
cout << 3 * 4 << "\n";
cout << 5 * 2 << "\n";
cout << 7 * 6 << "\n";
return 0;
}
// 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;
}
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.
#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;
}
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”.
// 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;
}
// nic nie oddaje - tylko dziala
void ramka(string tekst) {
cout << "+------------+\n";
cout << "| " << tekst << " |\n";
cout << "+------------+\n";
}
int main() {
ramka("Czesc!");
return 0;
}
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.
#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;
}
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.
// 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;
}
// 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;
}
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.
#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;
}
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.
#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;
}
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.
| Zapis | Co znaczy | Kiedy 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.
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.int, dwa parametry i jedną linijkę ciała. Pamiętaj, żeby napisać je powyżej main.Pokaż rozwiązanie
#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;
}
czyPierwsza(n) zwracającą bool. Wczytaj n liczb i dla każdej wypisz TAK albo NIE.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
#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;
}
void ramka(string s), która wypisuje podany tekst otoczony ramką z gwiazdek dopasowaną do jego długości.void. Górna i dolna linia ma tyle gwiazdek, ile znaków ma tekst plus 4 — wypiszesz je pętlą.Pokaż rozwiązanie
#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;
}
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.int&. W środku potrzebna jest trzecia zmienna pomocnicza — tak jak przy przelewaniu wody między szklankami.Pokaż rozwiązanie
#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;
}
nwd(a, b) zwracającą największy wspólny dzielnik dwóch liczb. Wczytaj dwie liczby i wypisz wynik.nwd(a, b) to to samo co nwd(b, a % b), a nwd(a, 0) to a.Pokaż rozwiązanie
#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;
}
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.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
#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
return nigdy się nie wykona. To nie błąd, tylko sposób na wcześniejsze wyjście.void, to każda gałąź if-a musi kończyć się return. Inaczej dostaniesz przypadkową wartość.void f(int& x) pracuje na oryginale, void f(int x) na kopii. Jeden znak, zupełnie inny efekt.const vector<int>& v nie kopiuje i nie pozwala zmieniać. Najlepszy wybór, gdy funkcja tylko czyta.