PricingLoginStart free
C++ Academy · leksjon

shared_ptr og weak_ptr – delt eierskap

Del eierskap med referansetelling, og bryt sirkler med weak_ptr.

Leksjon 3 av 413 trinn

shared_ptr og weak_ptr – delt eierskap er en gratis leksjon i C++ Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C++ Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Dele et objekt

Noen ganger må flere deler av programmet holde et objekt i live. std::shared_ptr<T> håndterer delt eierskap med referansetelling.

Opprette en shared_ptr

Bruk std::make_shared – den allokerer kontrollblokken og objektet i én enkelt allokering.

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

Kopiering deler eierskapet

Ved kopiering av en shared_ptr økes referansetelleren. Når den destrueres eller tilordnes på nytt, reduseres telleren. Når telleren når 0, slettes objektet.

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

Slik fungerer den under panseret

En shared_ptr inneholder to pekere: én til objektet og én til en kontrollblokk som inneholder referansetelleren eller -tellerne. Kontrollblokken allokeres på heapen.

Atomisk referanseteller

Referansetelleren bruker atomiske operasjoner, slik at shared_ptr-er kan kopieres trygt mellom tråder. Selve objektet det pekes på, er imidlertid ikke automatisk trådsikkert.

Tilbakestille og tilordne på nytt

Ved tilordning av en ny verdi reduseres den gamle referansetelleren, og den nye økes. reset() setter shared_ptr-en til tom.

shared_ptr fra råpeker (unngå)

Ikke konstruer to shared_ptr-objekter fra den samme råpekeren – begge vil da ha hver sin kontrollblokk. Bruk alltid make_shared.

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

Syklusproblemet

To shared_ptr-objekter som refererer til hverandre, danner en syklus – ingen av referansetellerne når null, og ingen av objektene frigjøres. Minn lekker.

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

Bryte sykluser med weak_ptr

std::weak_ptr<T> observerer en shared_ptr uten å delta i referansetellingen. Gjør den ene siden av en relasjon svak for å bryte syklusen.

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

Bruke weak_ptr

En weak_ptr kan ikke derefereres direkte. Kall lock() for å få en shared_ptr (eller en tom shared_ptr hvis objektet er ødelagt).

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";
}

Kostnad sammenlignet med unique_ptr

shared_ptr er større (to pekere + kontrollblokk) og tregere (atomisk referansetelling). Bruk den bare når eierskapet faktisk må deles.

Kort sjekk

Hva er det typiske bruksområdet for std::weak_ptr?

Besvar den i den interaktive leksjonen

Oppsummering

shared_ptr holder oversikt over eierskap med en atomisk referansetelling. Bruk make_shared, vær oppmerksom på sykluser, og bryt dem med weak_ptr. Foretrekk unique_ptr når deling ikke er nødvendig.

Gratis å komme i gang

Lær deg C++ med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
51
Leksjoner
203
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «shared_ptr og weak_ptr – delt eierskap» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien C++ Academy, inkludert «shared_ptr og weak_ptr – delt eierskap», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «shared_ptr og weak_ptr – delt eierskap»?

Del eierskap med referansetelling, og bryt sirkler med weak_ptr. Du øver på C++ Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C++ Academy?

Ingen tidligere erfaring er nødvendig. C++ Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «shared_ptr og weak_ptr – delt eierskap»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C++ Academy-leksjonen?

Ja. Alle C++ Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Hvorfor smartpekere erstatter rå new og delete
  2. unique_ptr og eksklusivt eierskap
  3. shared_ptr og weak_ptr – delt eierskap
  4. Tilpassede slettingsfunksjoner og make-funksjoner
← Tilbake til C++ Academy