C++ - inteligentné ukazovatele: unique_ptr, shared_ptr a weak_ptr
Ručné párovanie new a delete je v C++ najčastejším zdrojom únikov pamäte a pádov programu. Stačí predčasný return alebo výnimka a delete sa nikdy nezavolá. Inteligentné ukazovatele z hlavičky <memory> tento problém riešia: pamäť uvoľnia samy, keď ju už nikto nepotrebuje.
Problém so surovým ukazovateľom
void spracuj()
{
Subor* s = new Subor("data.txt");
if (!s->jeOtvoreny())
return; // únik pamäte – delete sa nezavolá
s->nacitaj(); // ak vyhodí výnimku, tiež únik
delete s;
}
unique_ptr – jediný vlastník
std::unique_ptr objekt vlastní výlučne. Keď zanikne (na konci bloku, pri výnimke, pri return), objekt sa automaticky zmaže. Nemá žiadnu réžiu navyše oproti surovému ukazovateľu, preto by mal byť prvou voľbou.
#include <memory>
void spracuj()
{
auto s = std::make_unique<Subor>("data.txt");
if (!s->jeOtvoreny())
return; // v poriadku, objekt sa zmaže
s->nacitaj(); // aj pri výnimke sa zmaže
}
unique_ptr sa nedá kopírovať – vlastník je len jeden. Vlastníctvo sa dá iba presunúť cez std::move:
std::unique_ptr<Subor> a = std::make_unique<Subor>("data.txt");
// std::unique_ptr<Subor> b = a; // chyba pri preklade
std::unique_ptr<Subor> b = std::move(a); // vlastníkom je teraz b
if (!a)
std::cout << "a je prázdny\n";
Funkcia, ktorá objekt vytvára, môže unique_ptr jednoducho vrátiť – volajúci sa stane vlastníkom:
std::unique_ptr<Tvar> vytvorTvar(const std::string& typ)
{
if (typ == "kruh")
return std::make_unique<Kruh>(1.0);
if (typ == "stvorec")
return std::make_unique<Stvorec>(2.0);
return nullptr;
}
std::vector<std::unique_ptr<Tvar>> tvary;
tvary.push_back(vytvorTvar("kruh"));
tvary.push_back(vytvorTvar("stvorec"));
Aby sa cez ukazovateľ na základnú triedu zavolal správny deštruktor, musí mať trieda Tvar virtuálny deštruktor.
shared_ptr – zdieľané vlastníctvo
std::shared_ptr sa kopírovať dá. Všetky kópie zdieľajú jeden objekt a spoločné počítadlo referencií; objekt sa zmaže, keď zanikne posledná kópia.
auto a = std::make_shared<Obrazok>("logo.png");
std::cout << a.use_count() << "\n"; // 1
{
std::shared_ptr<Obrazok> b = a; // kópia, počítadlo +1
std::cout << a.use_count() << "\n"; // 2
} // b zaniká, počítadlo -1
std::cout << a.use_count() << "\n"; // 1
// obrázok sa zmaže, keď zanikne aj a
Počítadlo je bezpečné pri použití z viacerých vlákien, čo niečo stojí. shared_ptr preto používajte len tam, kde objekt naozaj nemá jedného jasného vlastníka.
weak_ptr – pozorovateľ bez vlastníctva
Ak sa dva objekty držia navzájom cez shared_ptr, počítadlo nikdy neklesne na nulu a pamäť sa neuvoľní:
struct Uzol
{
std::shared_ptr<Uzol> dalsi;
std::shared_ptr<Uzol> predosly; // ZLE: cyklus
};
auto prvy = std::make_shared<Uzol>();
auto druhy = std::make_shared<Uzol>();
prvy->dalsi = druhy;
druhy->predosly = prvy; // ani jeden uzol sa nikdy nezmaže
Riešením je std::weak_ptr. Ukazuje na objekt spravovaný cez shared_ptr, ale počítadlo nezvyšuje. Pred použitím ho treba metódou lock() zmeniť na shared_ptr – ak objekt medzitým zanikol, výsledok je prázdny.
struct Uzol
{
std::shared_ptr<Uzol> dalsi;
std::weak_ptr<Uzol> predosly; // DOBRE: spätný odkaz nevlastní
};
void vypisPredosly(const Uzol& uzol)
{
if (std::shared_ptr<Uzol> p = uzol.predosly.lock())
std::cout << "predošlý uzol existuje\n";
else
std::cout << "predošlý uzol už neexistuje\n";
}
Prečo make_unique a make_shared
- V kóde sa nevyskytuje
new, takže nie je čo zabudnúť zmazať. - Typ sa píše iba raz:
auto p = std::make_unique<Subor>("data.txt"); make_sharedvyhradí objekt aj počítadlo jednou alokáciou namiesto dvoch.
Ako odovzdávať parametre
void vykresli(const Tvar& tvar); // funkcia objekt iba používa void pridaj(std::unique_ptr<Tvar> tvar); // funkcia preberá vlastníctvo void zapamataj(std::shared_ptr<Tvar> tvar); // funkcia si ponechá podiel vykresli(*tvar); pridaj(std::move(tvar));
Funkcia, ktorá objekt len používa a neukladá si ho, má dostať obyčajnú referenciu alebo surový ukazovateľ. Surový ukazovateľ ako taký nie je zlý – zlý je surový ukazovateľ, ktorý objekt vlastní.
Zhrnutie
unique_ptr– predvolená voľba, jeden vlastník, nulová réžia.shared_ptr– len keď má objekt viac rovnocenných vlastníkov.weak_ptr– spätné odkazy a vyrovnávacie pamäte, rozbíja cykly.- Objekty vytvárajte cez
make_uniqueamake_shared, nie ceznew.