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í.
#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";
}1 10std::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.
#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";
}1 2 1Na 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í.
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.
#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";
}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ápis | Vý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:
#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";
}2
3byVal 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.
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] = ...;.
#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";
}Adam=29 Eva=17
7 sevenMapa 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&.
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.
#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";
}42 -1 0parse("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.
Co vypíše optional?
Vyber správně
Spoj pojem s významem
Ke každému pojmu najdi popis.
Který ukazatel?
Roztřiď situace podle nejvhodnějšího nástroje.
Co udělá std::unique_ptr<int> c = b;, kde b je unique_ptr<int>?
Jediný vlastník nesmí být dva. Použij std::move(b).
Co vypíše int x = 1; auto f = [x]() mutable { return ++x; }; f(); std::cout << x;?
Lambda má vlastní kopii x. mutable dovolí měnit kopii, ne originál.
Který zápis bezpečně přečte hodnotu, i když opt může být prázdné?
value_or vrátí náhradní hodnotu. *opt na prázdném optionalu je nedefinované chování.
Proč může shared_ptr způsobit únik paměti?
Cyklus ze shared_ptr se nikdy neuvolní. Jednu stranu uděl weak_ptr.
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.