C++ Academy · Oppitunti

shared_ptr ja weak_ptr: jaettu omistajuus

Jaa omistajuus viitelaskennalla ja katkaise syklit weak_ptrin avulla.

Oppitunti 3/413 vaihetta

shared_ptr ja weak_ptr: jaettu omistajuus on ilmainen C++ Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu C++ Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. C++ Academy-kurssilla on yhteensä 4 oppituntia.

Olion jakaminen

Joskus ohjelman useiden osien täytyy pitää olio elossa. std::shared_ptr<T> hallitsee jaettua omistajuutta viitelaskennan avulla.

shared_ptr-osoittimen luominen

Käyttäkää std::make_shared-funktiota. Se varaa ohjauslohkon ja olion yhdellä varauksella.

#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count();   // 1

Kopiointi jakaa omistajuuden

shared_ptr-osoittimen kopiointi kasvattaa viitelaskuria. Tuhoaminen tai uuden arvon sijoittaminen pienentää sitä. Kun laskurin arvo saavuttaa nollan, olio poistetaan.

auto a = std::make_shared<Widget>();
auto b = a;                  // ref count is now 2
std::cout << a.use_count();  // 2

Miten se toimii taustalla

shared_ptr sisältää kaksi osoitinta: yhden olioon ja toisen ohjauslohkoon, joka sisältää viitelaskurin tai -laskurit. Ohjauslohko varataan kekomuistista.

Atominen viitelaskuri

Viitelaskuri käyttää atomisia operaatioita, joten shared_ptr-osoittimia voidaan kopioida säikeiden välillä turvallisesti. Osoittimen kohteena oleva olio ei kuitenkaan muutu automaattisesti säieturvalliseksi.

Nollaaminen ja uuden arvon sijoittaminen

Uuden arvon sijoittaminen pienentää vanhaa viitelaskuria ja kasvattaa uutta. reset() asettaa shared_ptr-osoittimen tyhjäksi.

shared_ptr raakaosoittimesta (vältä)

Älkää muodostako kahta shared_ptr-oliota samasta raakaosoittimesta — kummallakin olisi oma ohjauslohko. Käyttäkää aina make_shared-funktiota.

// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw);   // disaster: two control blocks

Sykliongelma

Kaksi toisiinsa viittaavaa shared_ptr-oliota muodostaa syklin — kummankaan viittauslaskuri ei saavuta nollaa, eikä kumpaakaan vapauteta. Seurauksena on muistivuoto.

struct Node {
    std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;     // cycle — never freed

Syklien katkaiseminen weak_ptr-osoittimilla

std::weak_ptr<T> tarkkailee shared_ptr-oliota osallistumatta viittauslaskuriin. Käyttäkää suhteen toisella puolella weak_ptr-osoitinta syklin katkaisemiseksi.

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>  prev;     // weak — does not own
};

weak_ptr-osoittimen käyttäminen

weak_ptr-osoitinta ei voi derivoida suoraan. Kutsukaa lock()-metodia saadaksenne shared_ptr-olion (tai tyhjän olion, jos kohde on jo tuhoutunut).

std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
    p->use();   // safe — we have a shared_ptr now
} else {
    std::cout << "object expired";
}

Kustannukset verrattuna unique_ptr-osoittimeen

shared_ptr on suurempi (kaksi osoitinta ja ohjauslohko) ja hitaampi (atominen viittauslaskuri). Käyttäkää sitä vain, kun omistajuus on todella jaettava.

Pikatarkistus

Mikä on std::weak_ptr-osoittimen tyypillinen käyttötapaus?

Vastaa interaktiivisessa oppitunnissa

Kertaus

shared_ptr seuraa omistajuutta atomisen viittauslaskurin avulla. Käyttäkää make_shared-funktiota, varokaa syklejä ja katkaiskaa ne weak_ptr-osoittimilla. Suosikaa unique_ptr-osoitinta, kun jakamiseen ei ole tarvetta.

Aloita maksutta

Opi C++ tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 51
Oppitunnit: 203

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”shared_ptr ja weak_ptr: jaettu omistajuus” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa C++ Academy-oppimispolun 3 oppituntia, myös oppitunnin “shared_ptr ja weak_ptr: jaettu omistajuus”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. C++ Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”shared_ptr ja weak_ptr: jaettu omistajuus”?

Jaa omistajuus viitelaskennalla ja katkaise syklit weak_ptrin avulla. Harjoittelet C++ Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni C++ Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin C++ Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”shared_ptr ja weak_ptr: jaettu omistajuus”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä C++ Academy-oppitunnilla?

Kyllä. Jokainen C++ Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Miksi älykkäät pointterit korvaavat raw new- ja delete-operaattorit
unique_ptr ja yksinomainen omistajuus
shared_ptr ja weak_ptr: jaettu omistajuus
Mukautetut poistajat ja make-funktiot

← Takaisin: C++ Academy