Postupy: Vytváření a používání instancí weak_ptr

Někdy musí objekt uložit způsob, jak získat přístup k podkladovému objektu shared_ptr , aniž by došlo k zvýšení počtu odkazů. K této situaci obvykle dochází v případě, že máte cyklické odkazy mezi shared_ptr instancemi.

Nejlepším návrhem je vyhnout se sdílenému vlastnictví ukazatelů, kdykoli je to možné. Pokud však potřebujete mít sdílené vlastnictví shared_ptr instancí, vyhněte se cyklickým odkazům mezi nimi. Pokud jsou cyklické odkazy z nějakého důvodu nepoužitelné nebo dokonce vhodnější, použijte weak_ptr dát jednomu nebo více vlastníkům slabý odkaz na jiný shared_ptr. Pomocí příkazu weak_ptrmůžete vytvořit shared_ptr propojení s existující sadou souvisejících instancí, ale pouze v případě, že základní prostředek paměti je stále platný. Sám weak_ptr o sobě se neúčastní počítání odkazů, a proto nemůže zabránit tomu, aby počet odkazů šel na nulu. Můžete ale použít weak_ptr k pokusu o získání nové kopie inicializované kopie shared_ptr . Pokud již byla paměť odstraněna, weak_ptrvrátí falseoperátor bool 's . Pokud je paměť stále platná, nový sdílený ukazatel zvýší počet odkazů a zaručuje, že paměť bude platná, pokud shared_ptr proměnná zůstane v oboru.

Příklad

Následující příklad kódu ukazuje případ, kdy weak_ptr se používá k zajištění správného odstranění objektů, které mají cyklické závislosti. Při zkoumání příkladu předpokládejme, že byla vytvořena až po zvážení alternativních řešení. Objekty Controller představují určitý aspekt strojového procesu a pracují nezávisle. Každý kontroler musí mít možnost dotazovat se na stav ostatních kontrolerů kdykoli a každý z nich pro tento účel obsahuje privátní vector<weak_ptr<Controller>> . Každý vektor obsahuje cyklický odkaz, a proto weak_ptr se instance používají místo shared_ptr.

#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class Controller
{
public:
   int Num;
   wstring Status;
   vector<weak_ptr<Controller>> others;
   explicit Controller(int i) : Num(i), Status(L"On")
   {
      wcout << L"Creating Controller" << Num << endl;
   }

   ~Controller()
   {
      wcout << L"Destroying Controller" << Num << endl;
   }

   // Demonstrates how to test whether the
   // pointed-to memory still exists or not.
   void CheckStatuses() const
   {
      for_each(others.begin(), others.end(), [](weak_ptr<Controller> wp) {
         auto p = wp.lock();
         if (p)
         {
            wcout << L"Status of " << p->Num << " = " << p->Status << endl;
         }
         else
         {
            wcout << L"Null object" << endl;
         }
      });
   }
};

void RunTest()
{
   vector<shared_ptr<Controller>> v{
       make_shared<Controller>(0),
       make_shared<Controller>(1),
       make_shared<Controller>(2),
       make_shared<Controller>(3),
       make_shared<Controller>(4),
   };

   // Each controller depends on all others not being deleted.
   // Give each controller a pointer to all the others.
   for (int i = 0; i < v.size(); ++i)
   {
      for_each(v.begin(), v.end(), [&v, i](shared_ptr<Controller> p) {
         if (p->Num != i)
         {
            v[i]->others.push_back(weak_ptr<Controller>(p));
            wcout << L"push_back to v[" << i << "]: " << p->Num << endl;
         }
      });
   }

   for_each(v.begin(), v.end(), [](shared_ptr<Controller> &p) {
      wcout << L"use_count = " << p.use_count() << endl;
      p->CheckStatuses();
   });
}

int main()
{
   RunTest();
   wcout << L"Press any key" << endl;
   char ch;
   cin.getline(&ch, 1);
}

Creating Controller0
Creating Controller1
Creating Controller2
Creating Controller3
Creating Controller4
push_back to v[0]: 1
push_back to v[0]: 2
push_back to v[0]: 3
push_back to v[0]: 4
push_back to v[1]: 0
push_back to v[1]: 2
push_back to v[1]: 3
push_back to v[1]: 4
push_back to v[2]: 0
push_back to v[2]: 1
push_back to v[2]: 3
push_back to v[2]: 4
push_back to v[3]: 0
push_back to v[3]: 1
push_back to v[3]: 2
push_back to v[3]: 4
push_back to v[4]: 0
push_back to v[4]: 1
push_back to v[4]: 2
push_back to v[4]: 3
use_count = 1
Status of 1 = On
Status of 2 = On
Status of 3 = On
Status of 4 = On
use_count = 1
Status of 0 = On
Status of 2 = On
Status of 3 = On
Status of 4 = On
use_count = 1
Status of 0 = On
Status of 1 = On
Status of 3 = On
Status of 4 = On
use_count = 1
Status of 0 = On
Status of 1 = On
Status of 2 = On
Status of 4 = On
use_count = 1
Status of 0 = On
Status of 1 = On
Status of 2 = On
Status of 3 = On
Destroying Controller0
Destroying Controller1
Destroying Controller2
Destroying Controller3
Destroying Controller4
Press any key

Jako experiment upravte vektor others tak, aby byl a vector<shared_ptr<Controller>>pak ve výstupu, všimněte si, že při RunTest návratu nejsou vyvolány žádné destruktory.

Viz také

Chytré ukazatele (moderní verze jazyka C++)