weak_ptr Klasa

Otacza słabo połączony wskaźnik.

Składnia

template<class T> class weak_ptr;

Parametry

T
Typ kontrolowany przez słaby wskaźnik.

Uwagi

Szablon klasy opisuje obiekt wskazujący zasób zarządzany przez co najmniej jeden shared_ptr obiekt. Obiekty weak_ptr wskazujące zasób nie mają wpływu na liczbę odwołań zasobu. Gdy ostatni shared_ptr obiekt zarządzający tym zasobem zostanie zniszczony, zasób zostanie zwolniony, nawet jeśli istnieją weak_ptr obiekty wskazujące ten zasób. Takie zachowanie jest niezbędne do uniknięcia cykli w strukturach danych.

weak_ptr Obiekt wskazuje zasób, jeśli został skonstruowany z shared_ptr obiektu, który jest właścicielem tego zasobu, jeśli został skonstruowany z obiektu wskazującego weak_ptr ten zasób, lub jeśli ten zasób został przypisany do niego za pomocą operator=polecenia . Obiekt weak_ptr nie zapewnia bezpośredniego dostępu do zasobu, do którego wskazuje. Kod, który musi używać zasobu, wykonuje to za pośrednictwem obiektu, który jest właścicielem shared_ptr tego zasobu, utworzony przez wywołanie funkcji lockskładowej . weak_ptr Obiekt wygasł, gdy zasób, na który wskazuje, został uwolniony, ponieważ wszystkie shared_ptr obiekty będące właścicielem zasobu zostały zniszczone. Wywołanie lock obiektu weak_ptr , który wygasł, powoduje utworzenie pustego shared_ptr obiektu.

Pusty weak_ptr obiekt nie wskazuje żadnych zasobów i nie ma bloku kontrolnego. Funkcja składowa lock zwraca pusty shared_ptr obiekt.

Cykl występuje, gdy co najmniej dwa zasoby kontrolowane przez shared_ptr obiekty przechowują wzajemnie odwołujące shared_ptr się do obiektów. Na przykład lista połączona cykliczna z trzema elementami ma węzeł N0główny ; ten węzeł zawiera shared_ptr obiekt, który jest właścicielem następnego węzła, N1; ten węzeł zawiera obiekt, który jest właścicielem shared_ptr następnego węzła; N2z kolei ten węzeł zawiera shared_ptr obiekt, który jest właścicielem węzła głównego, N0, zamykając cykl. W takiej sytuacji liczba odwołań nigdy nie staje się równa zero, a węzły w cyklu nigdy nie są zwalniane. Aby wyeliminować cykl, ostatni węzeł N2 powinien przechowywać weak_ptr obiekt wskazujący N0 zamiast shared_ptr obiektu. weak_ptr Ponieważ obiekt nie jest właścicielemN0, nie ma wpływu na N0liczbę odwołań, a ostatnie odwołanie programu do węzła głównego zostanie zniszczone węzły na liście.

Elementy członkowskie

Nazwa/nazwisko	opis
Konstruktory
weak_ptr	Tworzy element weak_ptr.
Destruktory
~weak_ptr	Niszczy element weak_ptr.
Definicje typów
element_type	Typ elementu.
Funkcje składowe
expired	Sprawdza, czy własność wygasła.
lock	Uzyskuje wyłączną własność zasobu.
owner_before	Zwraca wartość true , jeśli jest to weak_ptr uporządkowane przed (lub mniejszym) podanym wskaźnikiem.
reset	Wydania należące do zasobu.
swap	Zamienia dwa weak_ptr obiekty.
use_count	Zlicza liczbę shared_ptr obiektów.
Operatory
operator=	Zastępuje zasób będący własnością.

element_type

Typ elementu.

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

Uwagi

Typ jest synonimem parametru Tszablonu .

Przykład

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

Sprawdza, czy własność wygasła, oznacza to, że odwołany obiekt został usunięty.

bool expired() const noexcept;

Uwagi

Funkcja składowa zwraca true wartość , jeśli *this wygasła, w przeciwnym razie false.

Przykład

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

Uzyskuje własność shared_ptr zasobu, który współdzieli własność zasobu.

shared_ptr<T> lock() const noexcept;

Uwagi

Funkcja składowa zwraca pusty shared_ptr obiekt, jeśli *this wygasł; w przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu, *this do którego wskazuje. Zwraca wartość równoważną niepodzielnemu wykonaniu expired() ? shared_ptr<T>() : shared_ptr<T>(*this)elementu .

Przykład

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

Zastępuje zasób będący własnością.

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 kontrolowany przez argument współużytkowany lub słaby wskaźnik.

ptr
Słaby wskaźnik lub wskaźnik udostępniony do skopiowania.

Uwagi

Wszystkie operatory zwalniają zasób wskazywany obecnie przez *this i przypisz własność zasobu o nazwie ptr do *this. Jeśli operator ulegnie awarii, pozostanie *this niezmieniony. Każdy operator ma efekt odpowiadający weak_ptr(ptr).swap(*this).

Przykład

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

Zwraca wartość true , jeśli jest to weak_ptr uporządkowane przed (lub mniejszym) podanym wskaźnikiem.

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
Odwołanie lvalue do elementu shared_ptr lub .weak_ptr

Uwagi

Funkcja składowa szablonu zwraca true wartość , jeśli *this jest uporządkowana przed ptr.

reset

Zwalnia należący do niego zasób.

void reset() noexcept;

Uwagi

Funkcja składowa zwalnia zasób wskazywany przez *this i konwertuje *this go na pusty weak_ptr obiekt.

Przykład

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

Zamienia dwa weak_ptr obiekty.

void swap(weak_ptr& wp) noexcept;

Obejmuje również specjalizację:

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

Parametry

wp
Słaby wskaźnik do zamiany.

Uwagi

Po obiekcie swapzasób pierwotnie wskazywany przez *this element jest wskazywany przez wpelement , a zasób pierwotnie wskazywany przez wp element jest wskazywany przez *thiselement . Funkcja nie zmienia liczby odwołań dla dwóch zasobów i nie zgłasza żadnych wyjątków. Efektem specjalizacji szablonu jest odpowiednik a.swap(b).

Przykład

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

Zlicza liczbę shared_ptr obiektów, które są właścicielem zasobu udostępnionego.

long use_count() const noexcept;

Uwagi

Funkcja składowa zwraca liczbę shared_ptr obiektów będących właścicielem zasobu wskazywanego przez *thiselement .

Przykład

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

Tworzy element 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 kontrolowany przez argument współużytkowany/słaby wskaźnik. Te konstruktory nie uczestniczą w rozwiązywaniu przeciążeń, chyba że Other* jest zgodny z element_type*.

wp
Słaby wskaźnik do skopiowania.

sp
Wskaźnik udostępniony do skopiowania.

Uwagi

Domyślny konstruktor tworzy pusty weak_ptr obiekt. Konstruktory, które przyjmują argument, każdy konstruuje pusty weak_ptr obiekt, jeśli wskaźnik argumentu jest pusty. W przeciwnym razie tworzą weak_ptr obiekt wskazujący zasób o nazwie argumentu. Liczba odwołań obiektu udostępnionego nie jest zmieniana.

Przykład

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

Niszczy element weak_ptr.

~weak_ptr();

Uwagi

Destruktor niszczy to weak_ptr , ale nie ma wpływu na liczbę odwołań obiektu, w którym znajduje się jego przechowywany wskaźnik.

Zobacz też

Odwołanie do plików nagłówka
<memory>
Klasa shared_ptr