`weak_ptr` Třída

Článek
10/12/2023

Zalomí slabě propojený ukazatel.

Syntaxe

template<class T> class weak_ptr;

Parametry

T
Typ řízený slabým ukazatelem.

Poznámky

Šablona třídy popisuje objekt, který odkazuje na prostředek spravovaný jedním nebo více shared_ptr objekty. Objekty weak_ptr , které odkazují na prostředek, nemají vliv na počet odkazů zdroje. Když dojde ke zničení posledního shared_ptr objektu, který tento prostředek spravuje, uvolní se prostředek, a to i v případě, že existují weak_ptr objekty odkazující na tento prostředek. Toto chování je nezbytné pro zabránění cyklům v datových strukturách.

weak_ptr Objekt odkazuje na prostředek, pokud byl vytvořen z objektushared_ptr, který tento prostředek vlastní, pokud byl vytvořen z objektuweak_ptr, který odkazuje na tento prostředek, nebo pokud byl k operator=němu přiřazen. weak_ptr Objekt neposkytuje přímý přístup k prostředku, na který odkazuje. Kód, který potřebuje použít prostředek, provede to prostřednictvím objektu shared_ptr , který vlastní daný prostředek vytvořený voláním členské funkce lock. Platnost weak_ptr objektu vypršela, když byl uvolněn prostředek, na který odkazuje, protože všechny shared_ptr objekty, které vlastní prostředek, byly zničeny. Volání lock objektu weak_ptr , jehož platnost vypršela, vytvoří prázdný shared_ptr objekt.

Prázdný weak_ptr objekt neodkazuje na žádné prostředky a nemá žádný řídicí blok. Její členová funkce lock vrátí prázdný shared_ptr objekt.

Cyklus nastane, když dva nebo více prostředků řízených shared_ptr objekty drží vzájemně odkazující shared_ptr objekty. Například kruhový propojený seznam se třemi prvky má hlavní uzel N0; tento uzel obsahuje shared_ptr objekt, který vlastní další uzel; N1tento uzel obsahuje shared_ptr objekt, který vlastní další uzel, N2a tento uzel zase obsahuje shared_ptr objekt, který vlastní hlavní uzel, N0a zavře cyklus. V takové situaci se počet odkazů nikdy nestane nulou a uzly v cyklu se nikdy neuskutečí. Aby se cyklus odstranil, měl by poslední uzel N2 obsahovat weak_ptr objekt odkazující na N0 místo objektu shared_ptr . weak_ptr Vzhledem k tomu, že objekt nevlastní, N0 nemá vliv na N0počet odkazů a když je poslední odkaz programu na hlavní uzel zničen, dojde také ke zničení uzlů v seznamu.

Členové

Jméno	popis
Konstruktory
`weak_ptr`	Vytvoří .`weak_ptr`
Destruktory
`~weak_ptr`	Zničí .`weak_ptr`
Definice typedef
`element_type`	Typ elementu.
Členské funkce
`expired`	Testuje, jestli vypršela platnost vlastnictví.
`lock`	Získá výhradní vlastnictví prostředku.
`owner_before`	Vrátí `true` , pokud je tento `weak_ptr` příkaz seřazen před zadaným ukazatelem (nebo menší než).
`reset`	Vydané verze vlastněného prostředku
`swap`	Prohodí dva `weak_ptr` objekty.
`use_count`	Spočítá počet `shared_ptr` objektů.
Operátory
`operator=`	Nahrazuje vlastněný prostředek.

`element_type`

Typ elementu.

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

Poznámky

Typ je synonymem pro parametr Tšablony .

Příklad

// 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`

Testuje, jestli vypršela platnost vlastnictví, tj. odkazovaný objekt byl odstraněn.

bool expired() const noexcept;

Poznámky

Členová funkce vrátí true , pokud *this vypršela platnost, jinak false.

Příklad

// 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 Získá vlastnictví prostředku.

shared_ptr<T> lock() const noexcept;

Poznámky

Členová funkce vrátí prázdný shared_ptr objekt, pokud *this vypršela platnost. V opačném případě vrátí shared_ptr<T> objekt, který vlastní prostředek, na který *this odkazuje. Vrátí hodnotu, která odpovídá atomické provádění expired() ? shared_ptr<T>() : shared_ptr<T>(*this).

Příklad

// 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=`

Nahrazuje vlastněný prostředek.

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;

Parametry

Other
Typ řízený argumentem sdíleným nebo slabým ukazatelem.

ptr
Slabý ukazatel nebo sdílený ukazatel ke kopírování.

Poznámky

Operátory uvolní prostředek, na *this který aktuálně odkazuje, a přiřazují vlastnictví prostředku pojmenovaného uživatelem ptr*this. Pokud se operátor nezdaří, zůstane *this beze změny. Každý operátor má efekt, který odpovídá weak_ptr(ptr).swap(*this).

Příklad

// 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`

Vrátí true , pokud je tento weak_ptr příkaz seřazen před zadaným ukazatelem (nebo menší než).

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;

Parametry

ptr
Odkaz lvalue na položku shared_ptr nebo na weak_ptr.

Poznámky

Členová funkce šablony vrátí true , pokud *this je seřazena před ptr.

`reset`

Uvolní vlastněný prostředek.

void reset() noexcept;

Poznámky

Členová funkce uvolní prostředek, na který *this odkazuje, a převede *this na prázdný weak_ptr objekt.

Příklad

// 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`

Prohodí dva weak_ptr objekty.

void swap(weak_ptr& wp) noexcept;

Zahrnuje také specializaci:

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

Parametry

wp
Slabý ukazatel, se kterým se má prohodit.

Poznámky

swapPo , zdroj, na který původně odkazuje*this, je odkazován na wp, a zdroj původně odkazován wp*thisna . Funkce nezmění počty odkazů pro oba prostředky a nevyvolá žádné výjimky. Účinek specializace šablony je ekvivalentem a.swap(b).

Příklad

// 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`

Spočítá počet shared_ptr objektů, které vlastní sdílený prostředek.

long use_count() const noexcept;

Poznámky

Členová funkce vrátí počet shared_ptr objektů, které vlastní prostředek, na který *thisodkazuje .

Příklad

// 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`

Vytvoří .weak_ptr

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;

Parametry

Other
Typ řízený argumentem sdíleným nebo slabým ukazatelem. Tyto konstruktory se neúčastní řešení přetížení, pokud Other* není kompatibilní s element_type*.

wp
Slabý ukazatel, který chcete zkopírovat.

sp
Sdílený ukazatel, který chcete zkopírovat.

Poznámky

Výchozí konstruktor vytvoří prázdný weak_ptr objekt. Konstruktory, které přebírají argument každý konstruktor prázdný weak_ptr objekt, pokud je ukazatel argumentu prázdný. Jinak vytvoří weak_ptr objekt, který odkazuje na prostředek pojmenovaný argumentem. Počet odkazů sdíleného objektu se nezmění.

Příklad

// 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`

Zničí .weak_ptr

~weak_ptr();

Poznámky

Destruktor to weak_ptr zničí, ale nemá žádný vliv na počet odkazů objektu, na který je uložený ukazatel bodů.

Viz také

Referenční informace k souborům hlaviček
<memory>
Třída shared_ptr

Sdílet prostřednictvím

weak_ptr Třída

Syntaxe

Parametry

Poznámky

Členové

element_type

Poznámky

Příklad

expired

Poznámky

Příklad

lock

Poznámky

Příklad

operator=

Parametry

Poznámky

Příklad

owner_before

Parametry

Poznámky

reset

Poznámky

Příklad

swap

Parametry

Poznámky

Příklad

use_count

Poznámky

Příklad

weak_ptr

Parametry

Poznámky

Příklad

~weak_ptr

Poznámky

Viz také

Váš názor

Váš názor

Další materiály

`weak_ptr` Třída

`element_type`

`expired`

`lock`

`operator=`

`owner_before`

`reset`

`swap`

`use_count`

`weak_ptr`

`~weak_ptr`