0 bodů

C++ · 28 min

Ukazatele, new a delete

Ukazatele, adresy, dynamická paměť přes new a delete, typické chyby (únik, dvojí delete, visící ukazatel) a proč chytré ukazatele a RAII.

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.

cpp
#include <iostream>

int main() {
    int x = 10;
    int* p = &x;
    *p = 25;
    std::cout << x << " " << *p << "\n";
}
text
25 25

p 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).

cpp
#include <iostream>

int main() {
    int a[3] = {1, 2, 3};
    int* p = a;
    std::cout << *p << " " << *(p + 2) << " " << p[1] << "\n";
}
text
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éž:

cpp
#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";
}
text
7 9 7

q 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.

Doplň

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[].

cpp
#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;
}
text
42
4

Na 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.

Doplň

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.

cpp
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):

cpp
#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";
}
text
start
ctor
inside
dtor
end

std::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++.

Doplň

Pořadí výpisu

Vyber

Vyber správně

Spoj dvojice

Spoj pojem s významem

Ke každému pojmu najdi význam.

Roztřiď

Bezpečné, nebo chyba?

Roztřiď kód podle toho, zda je v pořádku.

Kvíz

Co je chyba v tomto kódu? int* p = new int(5); delete p; *p = 7;

Kvíz

Co udělá delete[]?

Kvíz

Který je nejlepší způsob, jak vlastnit jeden dynamicky alokovaný objekt?

Kvíz

Co vypíše int a[3] = {5, 6, 7}; int* p = a; std::cout << *(p + 1);?

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í.

Kartičky

Kartičky: ukazatele a paměť