`weak_ptr` Sınıf

Zayıf bağlantılı bir işaretçi sarar.

Sözdizimi

template<class T> class weak_ptr;

Parametreler

T
Zayıf işaretçi tarafından denetlenen tür.

Açıklamalar

Sınıf şablonu, bir veya daha fazla shared_ptr nesne tarafından yönetilen bir kaynağa işaret eden bir nesneyi açıklar. Bir weak_ptr kaynağı işaret eden nesneler kaynağın başvuru sayısını etkilemez. Kaynağı yöneten son shared_ptr nesne yok edildiğinde, kaynağı işaret eden nesneler olsa weak_ptr bile kaynak serbest kalır. Bu davranış, veri yapılarındaki döngüleri önlemek için gereklidir.

Bir weak_ptr nesne, kaynağın sahibi olan bir shared_ptr nesneden oluşturulduysa, bu kaynağa işaret eden bir weak_ptr nesneden oluşturulduysa veya bu kaynak ile operator=bu kaynağa atanmışsa bir kaynağa işaret eder. Nesne weak_ptr , işaret eden kaynağa doğrudan erişim sağlamaz. Kaynağı kullanması gereken kod bunu, üye işlevi lockçağrılarak oluşturulan kaynağa sahip olan bir shared_ptr nesne aracılığıyla yapar. Kaynağa weak_ptr sahip olan tüm shared_ptr nesneler yok edildiğinden, işaret ettiği kaynak serbest bırakıldığında nesnenin süresi doldu. Süresi dolmuş bir weak_ptr nesnenin çağrılması lock boş shared_ptr bir nesne oluşturur.

Boş weak_ptr bir nesne hiçbir kaynağa işaret etmez ve denetim bloğu yoktur. Üye işlevi lock boş shared_ptr bir nesne döndürür.

Nesneler tarafından shared_ptr denetlenen iki veya daha fazla kaynak karşılıklı başvuruda shared_ptr bulunan nesneleri barındırdığında bir döngü oluşur. Örneğin, üç öğe içeren döngüsel bağlantılı bir listenin baş düğümü vardır; bu düğüm bir sonraki düğümün N0N1sahibi olan bir shared_ptr nesneyi barındırıyor; bu düğüm bir sonraki düğümün N2sahibi olan bir shared_ptr nesneyi barındırıyor; bu düğüm de döngüyü kapatan baş düğümün N0sahibi olan bir shared_ptr nesneyi barındırıyor. Bu durumda başvuru sayıları hiçbir zaman sıfır olmaz ve döngüdeki düğümler hiçbir zaman serbest kalmaz. Döngüyü ortadan kaldırmak için, son düğüm N2 nesne weak_ptr yerine işaret eden N0 bir shared_ptr nesneyi tutmalıdır. Nesnenin weak_ptr sahibi N0 olmadığından , 'nin başvuru sayısını etkilemez N0ve programın baş düğüme son başvurusu yok edildiğinde listedeki düğümler de yok edilir.

Üyeler

Veri Akışı Adı	Açıklama
Oluşturucular
`weak_ptr`	bir `weak_ptr`oluşturur.
Yıkıcılar
`~weak_ptr`	Bir `weak_ptr`yok eder.
Tür tanımları
`element_type`	Öğesinin türü.
Üye işlevleri
`expired`	Sahipliğin süresinin dolduğunu test eder.
`lock`	Bir kaynağın özel sahipliğini alır.
`owner_before`	Bu`weak_ptr`, sağlanan işaretçiden önce (veya küçüktür) sıralanmışsa döndürür`true`.
`reset`	Sahip olunan kaynağı serbest bırakır.
`swap`	İki `weak_ptr` nesneyi değiştirir.
`use_count`	Nesne sayısını `shared_ptr` sayar.
İşleçler
`operator=`	Sahip olunan kaynağı değiştirir.

`element_type`

Öğesinin türü.

typedef T element_type; // through C++17
using element_type = remove_extent_t<T>; // C++20

Açıklamalar

türü, şablon parametresi Tiçin bir eş anlamlıdır.

Örnek

// std__memory__weak_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::weak_ptr<int>::element_type val = *wp0.lock();

    std::cout << "*wp0.lock() == " << val << std::endl;

    return (0);
}

*wp0.lock() == 5

`expired`

Sahipliğin süresinin dolduğunu, yani başvurulan nesnenin silinip silinmediğini test eder.

bool expired() const noexcept;

Açıklamalar

Üye işlevi, süresi dolduysa *this döndürürtrue, aksi takdirde false.

Örnek

// std__memory__weak_ptr_expired.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

`lock`

shared_ptr Bir kaynağın sahipliğini paylaşan bir alır.

shared_ptr<T> lock() const noexcept;

Açıklamalar

Üye işlevi süresi dolmuşsa *this boş shared_ptr bir nesne döndürür; aksi takdirde işaret eden *this kaynağa sahip olan bir shared_ptr<T> nesne döndürür. atomik yürütmesine expired() ? shared_ptr<T>() : shared_ptr<T>(*this)eşdeğer bir değer döndürür.

Örnek

// std__memory__weak_ptr_lock.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

`operator=`

Sahip olunan kaynağı değiştirir.

weak_ptr& operator=(const weak_ptr& ptr) noexcept;

template <class Other>
weak_ptr& operator=(const weak_ptr<Other>& ptr) noexcept;

template <class Other>
weak_ptr& operator=(const shared_ptr<Other>& ptr) noexcept;

Parametreler

Other
Paylaşılan veya zayıf işaretçi bağımsız değişkeni tarafından denetlenen tür.

ptr
Kopyalanacak zayıf işaretçi veya paylaşılan işaretçi.

Açıklamalar

İşleçlerin tümü şu anda tarafından işaret edilen *this kaynağı serbest bırakır ve tarafından adlı ptr kaynağın sahipliğini olarak *thisatar. Bir işleç başarısız olursa, değişmeden kalır *this . Her işleç ile weak_ptr(ptr).swap(*this)eşdeğer bir etkiye sahiptir.

Örnek

// std__memory__weak_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::shared_ptr<int> sp1(new int(10));
    wp0 = sp1;
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::weak_ptr<int> wp1;
    wp1 = wp0;
    std::cout << "*wp1.lock() == " << *wp1.lock() << std::endl;

    return (0);
}

*wp0.lock() == 5
*wp0.lock() == 10
*wp1.lock() == 10

`owner_before`

Buweak_ptr, sağlanan işaretçiden önce (veya küçüktür) sıralanmışsa döndürürtrue.

template <class Other>
bool owner_before(const shared_ptr<Other>& ptr) const noexcept;

template <class Other>
bool owner_before(const weak_ptr<Other>& ptr) const noexcept;

Parametreler

ptr
veya lvalue öğesine shared_ptr weak_ptrbaşvuru.

Açıklamalar

Şablon üyesi işlevi, öncesinde ptrsıralanmışsa *this döndürürtrue.

`reset`

Sahip olunan kaynağı serbest bırakır.

void reset() noexcept;

Açıklamalar

Üye işlevi tarafından işaret edilen *this kaynağı serbest bırakır ve boş weak_ptr bir nesneye dönüştürür*this.

Örnek

// std__memory__weak_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp(new int(5));
    std::weak_ptr<int> wp(sp);
    std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    wp.reset();
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    return (0);
}

*wp.lock() == 5
wp.expired() == false
wp.expired() == true

`swap`

İki weak_ptr nesneyi değiştirir.

void swap(weak_ptr& wp) noexcept;

Ayrıca uzmanlık da içerir:

template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

Parametreler

wp
Takas için zayıf işaretçi.

Açıklamalar

bir swapsonrasında, başlangıçta tarafından işaret edilen *this kaynak tarafından wpişaret edilir ve başlangıçta tarafından wp işaret edilen kaynak tarafından *thisişaret edilir. İşlev, iki kaynağın başvuru sayısını değiştirmez ve hiçbir özel durum oluşturmaz. Şablon özelleştirmesinin etkisi ile eşdeğerdir a.swap(b).

Örnek

// std__memory__weak_ptr_swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::shared_ptr<int> sp2(new int(10));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    sp1.swap(sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;

    swap(sp1, sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << std::endl;

    std::weak_ptr<int> wp1(sp1);
    std::weak_ptr<int> wp2(sp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    wp1.swap(wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    swap(wp1, wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    return (0);
}

*sp1 == 5
*sp1 == 10
*sp1 == 5

*wp1 == 5
*wp1 == 10
*wp1 == 5

`use_count`

Paylaşılan kaynağa sahip olan nesne sayısını shared_ptr sayar.

long use_count() const noexcept;

Açıklamalar

üye işlevi, tarafından *thisişaret edilen kaynağa sahip olan nesne sayısını shared_ptr döndürür.

Örnek

// std__memory__weak_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    std::shared_ptr<int> sp2(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    return (0);
}

wp.use_count() == 1
wp.use_count() == 2

`weak_ptr`

bir weak_ptroluşturur.

constexpr weak_ptr() noexcept;

weak_ptr(const weak_ptr& wp) noexcept;

weak_ptr(weak_ptr&& wp) noexcept;

template <class Other>
weak_ptr(const weak_ptr<Other>& wp) noexcept;

template <class Other>
weak_ptr(weak_ptr<Other>&& sp) noexcept;

template <class Other>
weak_ptr(const shared_ptr<Other>& sp) noexcept;

Parametreler

Other
Paylaşılan/zayıf işaretçi bağımsız değişkeni tarafından denetlenen tür. Bu oluşturucular ile element_type*uyumlu olmadığı sürece Other* aşırı yükleme çözümlemeye katılmaz.

wp
Kopyalanacak zayıf işaretçi.

sp
Kopyalanacak paylaşılan işaretçi.

Açıklamalar

Varsayılan oluşturucu boş weak_ptr bir nesne oluşturur. Bağımsız değişken işaretçisi boşsa bağımsız değişken alan oluşturucuların her biri boş weak_ptr bir nesne oluşturur. Aksi takdirde, bağımsız değişkeni tarafından adlandırılan kaynağa işaret eden bir weak_ptr nesne oluştururlar. Paylaşılan nesnenin başvuru sayısı değiştirilmez.

Örnek

// std__memory__weak_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp0;
    std::cout << "wp0.expired() == " << std::boolalpha
        << wp0.expired() << std::endl;

    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp1(sp1);
    std::cout << "*wp1.lock() == "
        << *wp1.lock() << std::endl;

    std::weak_ptr<int> wp2(wp1);
    std::cout << "*wp2.lock() == "
        << *wp2.lock() << std::endl;

    return (0);
}

wp0.expired() == true
*wp1.lock() == 5
*wp2.lock() == 5

`~weak_ptr`

Bir weak_ptryok eder.

~weak_ptr();

Açıklamalar

Yıkıcı bunu weak_ptr yok eder, ancak depolanan işaretçisinin işaret ettiği nesnenin başvuru sayısı üzerinde hiçbir etkisi yoktur.

Ayrıca bkz.

Üst Bilgi Dosyaları Başvurusu
<memory>
shared_ptr sınıfı

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

weak_ptr Sınıf

Sözdizimi

Parametreler

Açıklamalar

Üyeler

element_type

Açıklamalar

Örnek

expired

Açıklamalar

Örnek

lock

Açıklamalar

Örnek

operator=

Parametreler

Açıklamalar

Örnek

owner_before

Parametreler

Açıklamalar

reset

Açıklamalar

Örnek

swap

Parametreler

Açıklamalar

Örnek

use_count

Açıklamalar

Örnek

weak_ptr

Parametreler

Açıklamalar

Örnek

~weak_ptr

Açıklamalar

Ayrıca bkz.

Geri Bildirim

Ek kaynaklar

`weak_ptr` Sınıf

`element_type`

`expired`

`lock`

`operator=`

`owner_before`

`reset`

`swap`

`use_count`

`weak_ptr`

`~weak_ptr`