Lidsky řečeno
Funkce je kuchyňský přístroj. Když mu podáš surovinu hodnotou, dostane její kopii a tvůj původní kus zůstane nedotčený. Když mu podáš referenci, dáš mu klíč od vlastní spíže: co s ní udělá, to se v ní opravdu změní. A konstantní reference je klíč, kterým jde jen nahlížet, ne přemisťovat.
Obtížnost: 3 z 5.
Funkce: deklarace a definice
Funkce má návratový typ, jméno, parametry a tělo. Musí být známá dřív, než ji zavoláš. Buď ji napíšeš před main, nebo před main dáš jen prototyp (deklaraci) a tělo napíšeš později.
#include <iostream>
int twice(int x); // prototyp
int main() {
std::cout << twice(21) << "\n";
}
int twice(int x) { // definice
return 2 * x;
}42Funkce s návratovým typem void nic nevrací. Parametry (v definici) jsou proměnné uvnitř funkce, argumenty (při volání) jsou hodnoty, které do nich přijdou.
Předání hodnotou a referencí
Výchozí chování v C++ je předání hodnotou: funkce dostane kopii. Reference & znamená „jiné jméno pro tutéž proměnnou“.
#include <iostream>
void byValue(int x) { x = 99; }
void byRef(int& x) { x = 99; }
int main() {
int a = 1, b = 1;
byValue(a);
byRef(b);
std::cout << a << " " << b << "\n";
}1 99byValue změnila svou kopii, a zůstalo 1. byRef změnila přímo b, proto 99. Typická užití reference: funkce, která má změnit argument (swap), nebo vrátit víc hodnot přes výstupní parametry.
void swapInts(int& x, int& y) {
int t = x;
x = y;
y = t;
}Zavolání swapInts(p, q) s p = 3, q = 8 vymění hodnoty, takže p je 8 a q je 3.
Hodnota, nebo reference?
Konstantní reference: bez kopie a bez změny
Kopírování velkého objektu (dlouhý std::string, std::vector) stojí čas. Přitom funkce často data jen čte. Řešení: const T&: žádná kopie, a překladač hlídá, že funkce objekt nezmění.
#include <iostream>
#include <string>
std::size_t len(const std::string& s) {
return s.size();
}
int main() {
std::cout << len("hello") << "\n";
}5Pravidlo, které se vyplatí si pamatovat:
| Situace | Jak předat |
|---|---|
Malý typ (int, double, char, bool), jen čteš | hodnotou: int x |
Velký typ (string, vector), jen čteš | const T& |
| Funkce má objekt změnit | T& |
| Chceš si vlastní kopii a upravit ji | hodnotou: T x |
Dočasné hodnoty (jako "hello", které se převede na std::string) se smí vázat jen na const T&, ne na obyčejnou T&.
Reference je jméno, ne ukazatel
Reference se musí inicializovat při vzniku a nikdy se nepřepojí jinam. Přiřazení do reference mění původní proměnnou.
#include <iostream>
int main() {
int a = 10;
int& r = a;
r = 20;
int b = 5;
r = b;
std::cout << a << " " << b << "\n";
}5 5r = 20 změní a na 20. Pak r = b nepřepojí r na b, jen zkopíruje hodnotu 5 do proměnné a, na kterou r ukazuje. Výsledek je 5 5.
Co vypíše reference?
Přetěžování funkcí
V C++ smí mít více funkcí stejné jméno, pokud se liší počtem nebo typy parametrů. Překladač vybere podle argumentů. Návratový typ k rozlišení nestačí.
#include <iostream>
#include <string>
void show(int x) { std::cout << "int " << x << "\n"; }
void show(double x) { std::cout << "double " << x << "\n"; }
void show(const std::string& s) { std::cout << "string " << s << "\n"; }
int main() {
show(5);
show(2.5);
show(std::string("hi"));
show(true);
}int 5
double 2.5
string hi
int 1show(true) vybere int verzi, protože bool se povyšuje na int (promotion), což je lepší než převod na double. Úskalí: show(5L) (typ long) je nejednoznačné, protože převod na int i na double jsou stejně dobré a překladač odmítne vybrat.
Výchozí argumenty
Parametry od konce můžou mít výchozí hodnotu. Uvádí se jen v deklaraci (prototypu), ne dvakrát.
#include <iostream>
int power(int base, int exp = 2) {
int r = 1;
for (int i = 0; i < exp; ++i) r *= base;
return r;
}
int main() {
std::cout << power(3) << " " << power(2, 5) << " " << power(5, 0) << "\n";
}9 32 1power(3) použije exp = 2, tedy 3 * 3 = 9. power(2, 5) je 32. power(5, 0) nespustí cyklus, zůstane r = 1.
Výchozí argumenty
Vyber správně
Spoj zápis s významem
Ke každému zápisu najdi význam.
Jak předat parametr?
Roztřiď parametry podle nejvhodnějšího předání.
Co je chyba v tomto kódu? int& f() { int x = 5; return x; }
Po skončení funkce x neexistuje. Reference „visí“ (dangling) a použití je nedefinované chování. Vracej hodnotu int f().
Který zápis se nepřeloží?
Přetížení se musí lišit parametry. Samotný návratový typ k rozlišení nestačí.
Co vypíše int a = 4; int& r = a; r++; std::cout << a;?
r je jiné jméno pro a, takže r++ zvětší a.
Proč void f(int& x) nejde zavolat jako f(5)?
Na T& se váže jen pojmenovaná proměnná. Dočasné hodnoty se smí vázat jen na const T& (nebo na T&&, o tom jindy).
Pod kapotou · Reference a hodnotové kategorie
Reference jsou v paměti obvykle implementované jako ukazatele, ale jazyk po nich vyžaduje, aby byly vždy platné a neměnné. Od C++11 existují i rvalue reference T&&, které se váží na dočasné hodnoty a umožňují přesun (std::move) místo kopie. U funkcí, které objekt jen čtou, se dnes volí const T&, u malých typů hodnota. Pro nahlížení do řetězce a polí bez kopie existují std::string_view (C++17) a std::span (C++20): objekt s ukazatelem a délkou, který nevlastní data. Pozor: jejich nebezpečí je stejné jako u dangling reference, protože data musí přežít pohled na ně. Přetížení vybírá překladač v pořadí: přesná shoda, povýšení, převod, uživatelský převod. Pokud dvě stejně dobré verze zbydou, je volání nejednoznačné.