Lidsky řečeno
Proměnná je pokoj v hotelu. Ukazatel je papírek s číslem pokoje. S papírkem nic neuděláš, dokud nedojdeš do pokoje (to je dereference). Dynamická paměť je pokoj, který si pronajmeš (new) a musíš ho vrátit (delete). Když pokoj vrátíš a papírek si necháš, jdeš do cizího pokoje. A když ho nevrátíš nikdy, hotel se postupně zaplní tvými prázdnými pokoji.
Obtížnost: 4 z 5.
Ukazatel a adresa
Ukazatel je proměnná, která drží adresu jiné proměnné. Operátor &x dá adresu proměnné x. Operátor *p (dereference) dá hodnotu na adrese uložené v p.
#include <iostream>
int main() {
int x = 10;
int* p = &x;
*p = 25;
std::cout << x << " " << *p << "\n";
}25 25p ukazuje na x. Zápis *p = 25; změní x, protože *p je x. Proto se oba výpisy rovnají. Prázdný ukazatel se píše nullptr (od C++11). Dereference nullptr je nedefinované chování.
Ukazatele a pole
Jméno pole se ve výrazu chová jako ukazatel na první prvek. K dalším prvkům se dostaneš přičtením čísla: p + 1 ukazuje na další prvek (posune se o velikost jednoho prvku).
#include <iostream>
int main() {
int a[3] = {1, 2, 3};
int* p = a;
std::cout << *p << " " << *(p + 2) << " " << p[1] << "\n";
}1 3 2*p je a[0], tedy 1. *(p + 2) je a[2], tedy 3. p[1] je jen jiný zápis pro *(p + 1), tedy 2.
Kdo se na koho dívá
Při kopírování ukazatele kopíruješ adresu, ne hodnotu. Proto dva ukazatele mohou mířit na totéž:
#include <iostream>
int main() {
int a = 1, b = 2;
int* p = &a;
int* q = p;
*q = 7;
q = &b;
*q = 9;
std::cout << a << " " << b << " " << *p << "\n";
}7 9 7q zprvu míří na a (kopie adresy z p), takže *q = 7 změní a. Potom se q přesměruje na b a *q = 9 změní b. Ukazatel p pořád míří na a, takže *p je 7.
Kdo se na koho dívá?
Dynamická paměť: new a delete
Lokální proměnné žijí jen do konce bloku. Paměť, která má žít déle, se alokuje na haldě (heap) přes new a musí se vrátit přes delete. Pole se alokuje new T[n] a vrací přes delete[].
#include <iostream>
int main() {
int* p = new int(42);
std::cout << *p << "\n";
delete p;
p = nullptr;
int* arr = new int[3]{1, 2, 3};
std::cout << arr[0] + arr[2] << "\n";
delete[] arr;
}42
4Na new int(42) vznikne jedno int s hodnotou 42. delete p; ho uvolní. Po uvolnění se ukazatel nastavuje na nullptr, aby nezůstal visící (dangling). arr[0] + arr[2] je 1 + 3 = 4. Pole musí končit delete[], ne delete.
Co vypíše new?
Co se pokazí
Ručně spravovaná paměť je zdroj nejznámějších chyb v C++. Všechny níže jsou nedefinované chování nebo únik paměti.
int* p = new int(5);
delete p;
std::cout << *p; // visící ukazatel: čtení uvolněné paměti
delete p; // dvojí delete
int* leak = new int(1);
leak = nullptr; // únik: adresa je ztracená, delete už nejde zavolat
int* arr = new int[3];
delete arr; // špatně: pole se musí uvolnit pomocí delete[]Žádný z těchto kódů ti kompilátor nezakáže, mnohdy ani nevaruje. Detaily najdeš v bloku „Typické chyby“ níže a nástroje na jejich hledání v bloku „Pod kapotou“.
Proč raději chytré ukazatele a RAII
Rozumný přístup v moderním C++: nepoužívej holé new a delete. Nechej paměť vlastnit objekt, který ji sám uvolní. Tomuhle principu se říká RAII (Resource Acquisition Is Initialization): zdroj se získá při vzniku objektu a uvolní při jeho zániku, tedy automaticky na konci bloku, i když nastane výjimka.
Ukázka s objektem, který při vzniku a zániku něco vypíše (třídy podrobně v další lekci):
#include <iostream>
#include <memory>
struct Noisy {
Noisy() { std::cout << "ctor\n"; }
~Noisy() { std::cout << "dtor\n"; }
};
int main() {
std::cout << "start\n";
{
auto p = std::make_unique<Noisy>();
std::cout << "inside\n";
}
std::cout << "end\n";
}start
ctor
inside
dtor
endstd::make_unique<Noisy>() (od C++14) vytvoří objekt na haldě a vrátí chytrý ukazatel std::unique_ptr. Na konci vnitřního bloku p zanikne a sám zavolá delete, což vypíše dtor. Žádné ruční uvolňování, žádný únik. Chytré ukazatele rozebereme podrobněji v lekci o moderním C++.
Pořadí výpisu
Vyber správně
Spoj pojem s významem
Ke každému pojmu najdi význam.
Bezpečné, nebo chyba?
Roztřiď kód podle toho, zda je v pořádku.
Co je chyba v tomto kódu? int* p = new int(5); delete p; *p = 7;
Po delete p je paměť uvolněná. Použití *p je nedefinované chování. Pomáhá nastavit p = nullptr hned po uvolnění.
Co udělá delete[]?
new[] a delete[] patří k sobě. delete bez závorek na pole je nedefinované chování.
Který je nejlepší způsob, jak vlastnit jeden dynamicky alokovaný objekt?
std::unique_ptr objekt uvolní automaticky při zániku, nelze zapomenout. Holé new je zdroj úniků.
Co vypíše int a[3] = {5, 6, 7}; int* p = a; std::cout << *(p + 1);?
p + 1 ukazuje na druhý prvek, *(p + 1) je 6.
Pod kapotou · Halda, zásobník a nástroje na hledání chyb
Lokální proměnné žijí na zásobníku (rychlý, malý, automaticky uklízený), dynamická paměť na haldě (větší, ruční správa). Chyby s pamětí se hledají nástroji: AddressSanitizer (g++ -fsanitize=address -g prog.cpp nebo Clang) zachytí visící ukazatele, přetečení a úniky za běhu, Valgrind na Linuxu spustí hotový program a hlídá paměť bez nutnosti zvláštního přepínače (hodí se přeložit s -g), MSVC má vlastní AddressSanitizer (/fsanitize=address). V moderním C++ platí pravidlo: holé new a delete se v aplikačním kódu nepoužívají, vlastnictví vyjadřují std::unique_ptr (jeden vlastník) a std::shared_ptr (sdílený vlastník), pro kolekce std::vector. Pravidlo nuly (rule of zero): když třída používá jen RAII členy, nepotřebuje psát vlastní destruktor ani kopírování.