0 bodů

C++ · 30 min

Moderní C++: chytré ukazatele a lambda

unique_ptr a shared_ptr, lambda se zachytáváním, structured bindings a std::optional: moderní nástroje C++11 až C++17 místo holého new.

Lidsky řečeno

Moderní C++ je jako chytrý zámek. Holé new a delete jsou klíč pod rohožkou: funguje, dokud si někdo nezapomene zamknout. unique_ptr je klíč, který má jen jeden člověk a když mu zanikne, dveře se samy zamknou. shared_ptr je společná klíčenka: byt se zamkne, až když ji vrátí poslední z členů rodiny. Lambda je malý vzkaz „až budeš něco dělat, udělej to takhle“, který nemusíš pojmenovávat.

Obtížnost: 4 z 5.

Tahle lekce vyžaduje aspoň C++17: přelož s -std=c++17 (nebo c++20). Ukázky tu používají make_unique (C++14), lambdy (C++11), structured bindings a std::optional (oba C++17).

unique_ptr: jeden vlastník

std::unique_ptr<T> (z <memory>) vlastní objekt a při svém zániku ho uvolní. Nejde ho kopírovat, jen přesunout (std::move) a tím předat vlastnictví.

cpp
#include <iostream>
#include <memory>

int main() {
    auto a = std::make_unique<int>(10);
    std::unique_ptr<int> b = std::move(a);
    std::cout << (a == nullptr) << " " << *b << "\n";
}
text
1 10

std::make_unique<int>(10) vytvoří int s hodnotou 10 na haldě. std::move(a) předá vlastnictví do b, a je po přesunu prázdné (nullptr), proto a == nullptr je pravda a vypíše 1. Hodnotu čteme přes *b: 10. Kopie std::unique_ptr<int> c = b; by se nepřeložila, protože jediný vlastník nesmí být dva.

shared_ptr: sdílené vlastnictví

std::shared_ptr<T> počítá, kolik ukazatelů na objekt míří. Objekt se uvolní, když počet klesne na nulu.

cpp
#include <iostream>
#include <memory>

int main() {
    auto p = std::make_shared<int>(5);
    std::cout << p.use_count() << " ";
    {
        auto q = p;
        std::cout << p.use_count() << " ";
    }
    std::cout << p.use_count() << "\n";
}
text
1 2 1

Na začátku je jeden ukazatel (1). Po auto q = p; jsou dva (2). Na konci vnitřního bloku q zanikne, počet klesne zpět na 1. Úskalí: dva objekty, které na sebe ukazují přes shared_ptr (cyklus), se nikdy neuvolní. Jednu stranu řeš přes std::weak_ptr, který počet nezvyšuje. shared_ptr je dražší než unique_ptr, proto je výchozí volba unique_ptr a shared_ptr jen při opravdu sdíleném vlastnictví.

Doplň

Vlastnictví a počítadlo

Lambda výrazy

Lambda je anonymní funkce, kterou napíšeš přímo na místě použití. Zápis: [zachycení](parametry) { tělo }. Do hranatých závorek patří proměnné z okolí, které lambda smí použít.

cpp
#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    int base = 10;
    auto addBase = [base](int x) { return x + base; };
    auto times = [](int a, int b) { return a * b; };
    std::cout << addBase(5) << " " << times(3, 4) << "\n";

    std::vector<int> v{3, 1, 2};
    std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });
    for (int x : v) std::cout << x << " ";
    std::cout << "\n";
}
text
15 12
3 2 1 

addBase si zachytila base (hodnotu 10), proto addBase(5) je 15. times(3, 4) je 12. Třetí lambda je porovnávač pro std::sort: vrací, zda má a jít před b, takže a > b seřadí sestupně: 3 2 1.

Zachytávání: hodnotou, nebo referencí

ZápisVýznam
[]nic nezachytávej
[x]zachyť x jako kopii (v době vzniku lambdy)
[&x]zachyť x jako referenci (vidí změny)
[=]všechno použité kopií
[&]všechno použité referencí

Kopie je v lambdě neměnná, pokud ji nepřidáš mutable. A i pak mění jen svou kopii:

cpp
#include <iostream>

int main() {
    int counter = 0;
    auto byVal = [counter]() mutable { return ++counter; };
    auto byRef = [&counter]() { return ++counter; };
    byVal();
    byVal();
    byRef();
    byRef();
    std::cout << counter << "\n";
    std::cout << byVal() << "\n";
}
text
2
3

byVal má vlastní kopii counter (začíná na 0), dvě volání ji zvýšila na 2, vnější counter se nezměnil. byRef mění vnější proměnnou, po dvou voláních je 2, to vypíše první řádek. Třetí volání byVal() zvýší její kopii z 2 na 3.

Doplň

Co vypíše lambda?

Structured bindings

Od C++17 jde rozbalit dvojici, n-tici nebo strukturu do pojmenovaných proměnných: auto [a, b] = ...;.

cpp
#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> ages{{"Eva", 17}, {"Adam", 29}};
    for (const auto& [name, age] : ages) {
        std::cout << name << "=" << age << " ";
    }
    std::cout << "\n";

    std::pair<int, std::string> p{7, "seven"};
    auto [num, word] = p;
    std::cout << num << " " << word << "\n";
}
text
Adam=29 Eva=17 
7 seven

Mapa je seřazená podle klíče (Adam před Eva), každý prvek je dvojice, kterou [name, age] rozebere na jméno a věk. Čitelnější než kv.first a kv.second. Druhá část rozloží std::pair na num = 7 a word = "seven". Stejně auto bez reference kopíruje, pro čtení bez kopie const auto&.

Doplň

Co vypíše rozbalení?

std::optional

std::optional<T> (z <optional>, C++17) je hodnota, která může chybět. Hodí se místo „magických“ návratových hodnot jako -1.

cpp
#include <iostream>
#include <optional>
#include <string>

std::optional<int> parse(const std::string& s) {
    if (s.empty() || s.find_first_not_of("0123456789") != std::string::npos) {
        return std::nullopt;
    }
    return std::stoi(s);
}

int main() {
    auto a = parse("42");
    auto b = parse("4x2");
    std::cout << a.value_or(-1) << " " << b.value_or(-1) << " " << b.has_value() << "\n";
}
text
42 -1 0

parse("42") vrátí číslo 42. parse("4x2") obsahuje písmeno, vrátí std::nullopt (prázdná hodnota). value_or(-1) dá hodnotu, nebo -1, když chybí. has_value() vrací bool, vypíše se 0. Pozor: *b nebo b.value() na prázdném optionalu: *b je nedefinované chování, b.value() vyhodí std::bad_optional_access.

Doplň

Co vypíše optional?

Vyber

Vyber správně

Spoj dvojice

Spoj pojem s významem

Ke každému pojmu najdi popis.

Roztřiď

Který ukazatel?

Roztřiď situace podle nejvhodnějšího nástroje.

Kvíz

Co udělá std::unique_ptr<int> c = b;, kde b je unique_ptr<int>?

Kvíz

Co vypíše int x = 1; auto f = [x]() mutable { return ++x; }; f(); std::cout << x;?

Kvíz

Který zápis bezpečně přečte hodnotu, i když opt může být prázdné?

Kvíz

Proč může shared_ptr způsobit únik paměti?

Pod kapotou · Chytré ukazatele pod kapotou a novinky

std::unique_ptr je prakticky jen ukazatel s destruktorem a nulovou režií při použití výchozího mazače. std::shared_ptr má řídicí blok s počítadly (sdílených a slabých odkazů), které se mění atomicky, takže je bezpečný pro vlákna při kopírování ukazatelů (samotný objekt ne). std::make_shared alokuje objekt a řídicí blok jedním blokem. Lambda je pro překladač objekt anonymní třídy s operator(), zachycené proměnné jsou její členy. Od C++14 jsou obecné lambdy ([](auto a, auto b)), od C++20 lambdy v šablonovém zápisu a koncepty. V C++20 přibyl std::format a v C++23 std::print v hlavičce <print> (ověř podporu ve svém překladači). std::expected z C++23 doplňuje optional o chybovou hodnotu.

Kartičky

Kartičky: moderní C++