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_shared vyhradí 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_unique a make_shared, nie cez new.
O autorovi

Ing.Jaroslav Vadel

Som zakladateľom www.projectik.eu. Hrám sa na programátora, ktorý ovláda: c#,cpp,java,unity3d,php,html,NI testand,NI Vision Builder,Cognex In-Sight,NI LabView "Naprogramovať program, ktorý funguje vie každy. Ale to, že program funguje ešte neznamena, že je napísany správne "

Súvisiace články