std::weak_ptr Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <memory>

Açıklaması şöyle

When the client uses the referenced object, it converts it to shared for the duration of use so that it isn't deleted. The client owning the weak_ptr needs some way to assume partial ownership of the lifetime of the object before using it.

Bu pointer türü shared_ptr nesnesine point eder ama shared_ptr'nin sayacını artırmaz.

Effective Modern C++ sayfa 144'teki açıklama şöyle. Eğer nesne make_shared() ile yaratılırsa Control Block ve Object beraberdir. Tüm shared_ptr'ler silinse bile bu nesneye weak_ptr varsa bu bellek geri verilmez.

As long as std::weak_ptrs refer to a control block (i.e., the weak count is greater than zero), that control block must continue to exist. And as long as a control block exists, the memory containing it must remain allocated. The memory allocated by a std::shared_ptr make function, then, can’t be deallocated until the last std::shared_ptr and the last std::weak_ptr referring to it have been destroyed.

Constructor - shared_ptr
İmzası şöyle.

template< class Y >
weak_ptr (const std::shared_ptr<Y>& r);

Açıklaması şöyle. Bir weak_ptr yaratmanın yolu önce shared_ptr nesnesi yaratmak ve atama yapmak.

Constructs new weak_ptr which shares an object managed by r. If r manages no object, *this manages no object too.

Şöyle yaparız.

std::shared_ptr<T> sharedPtr = ...;
std::weak_ptr<T> w {sharedPtr};

Şöyle yaparız.

std::shared_ptr<int> sharedPtr = std::make_shared<int> (10);
std::weak_ptr<int> weakPtr (sharedPtr);

expired metodu

Şöyle yaparız.

bool expired =  m_ptr.expired();

lock metodu

weak_ptr'den tekrar shared_ptr elde etmeye yarar.
Örnek
Şöyle yaparız.

shared_ptr<int> sharedPtr = weakPtr.lock()

Örnek
If içinde kullanmak için şöyle yaparız.

if (auto sharedPtr = weakPtr.lock()) {
// ptr is valid and can now be used via the shared_ptr shared
} else {
    // ptr is nullptr
}

operator == metodu
Böyle bir metod yok. Açıklaması şöyle

weak_ptr itself has no operator ==, so you cannot find it in vector. You should cast it to shared_ptr and only then compare. So you should use lock function on each object. Or compare not pointers, but objects by some criteria

Elimizde şöyle bir kod olsun

std::vector<std::weak_ptr<Foo>> objects_;

Şöyle yaparız.

void addObject(std::weak_ptr<Foo> obj)
{
  auto pos = std::find_if
  (
    objects_.begin(), objects_.end(),
    [&obj](const auto& our_obj)
    {
      return obj.lock() == our_obj.lock();
    }
  );
  if (pos == objects_.end())
  {
    std::cout << "Object added" << std::endl;
    objects_.push_back(obj);
  }
}

Çağırmak için şöyle yaparız.

std::shared_ptr<Object> obj1 = std::make_shared<Object>();
addObject(obj1);