`weak_ptr` 클래스

아티클
10/12/2023

약하게 링크된 포인터를 래핑합니다.

구문

template<class T> class weak_ptr;

매개 변수

T
약한 포인터에 의해 제어되는 형식입니다.

설명

클래스 템플릿은 하나 이상의 shared_ptr 개체로 관리되는 리소스를 가리키는 개체를 설명합니다. 리소스를 가리키는 개체는 weak_ptr 리소스의 참조 수에 영향을 주지 않습니다. 해당 리소스를 관리하는 마지막 shared_ptr 개체가 제거되면 해당 리소스를 가리키는 개체가 있더라도 리소스가 해제됩니다 weak_ptr . 이 동작은 데이터 구조의 주기를 방지하는 데 필수적입니다.

개체는 weak_ptr 해당 리소스를 소유하는 개체에서 shared_ptr 생성된 경우, 해당 리소스를 가리키는 개체에서 weak_ptr 생성된 경우 또는 해당 리소스를 사용하여 operator=리소스를 할당한 경우 리소스를 가리킵니다. 개체는 weak_ptr 가리키는 리소스에 대한 직접 액세스를 제공하지 않습니다. 리소스를 사용해야 하는 코드는 멤버 함수lock를 shared_ptr 호출하여 만든 해당 리소스를 소유하는 개체를 통해 수행됩니다. weak_ptr 리소스를 소유한 모든 shared_ptr 개체가 삭제되어 가리키는 리소스가 해제되면 개체가 만료되었습니다. 만료된 개체를 weak_ptr 호출 lock 하면 빈 shared_ptr 개체가 만들어집니다.

빈 weak_ptr 개체는 리소스를 가리키지 않으며 제어 블록이 없습니다. 해당 멤버 함수 lock 는 빈 shared_ptr 개체를 반환합니다.

shared_ptr 개체가 제어하는 둘 이상의 리소스가 상호 참조하는 shared_ptr 개체를 보유한 경우 순환이 발생합니다. 예를 들어 요소 세 개가 포함된 순환 연결된 목록에 헤드 노드 N0가 있습니다. 해당 노드는 다음 노드 N1을 소유하는 shared_ptr 개체를 보유합니다. 해당 노드는 다음 노드 N2를 소유하는 shared_ptr 개체를 보유합니다. 해당 노드는 다시 헤드 노드 N0을 소유하는 shared_ptr 개체를 보유하여 순환을 닫습니다. 이 경우 참조 수는 0이 되지 않으며 주기의 노드는 해제되지 않습니다. 순환을 제거하려면 마지막 노드 N2가 shared_ptr 개체 대신 N0을 가리키는 weak_ptr 개체를 보유해야 합니다. 개체는 weak_ptr 소유 N0 하지 않으므로 '의 참조 수에 영향을 N0주지 않으며, 헤드 노드에 대한 프로그램의 마지막 참조가 제거되면 목록의 노드도 제거됩니다.

멤버

속성	설명
생성자
`weak_ptr`	`weak_ptr`를 생성합니다.
소멸자
`~weak_ptr`	`weak_ptr`을 삭제합니다.
Typedefs
`element_type`	요소의 형식입니다.
멤버 함수
`expired`	소유권이 만료되었는지 테스트합니다.
`lock`	리소스의 단독 소유권을 가져옵니다.
`owner_before`	이 `weak_ptr`이 제공된 포인터 앞에 정렬(또는 보다 작음)되는 경우 `true`를 반환합니다.
`reset`	소유하는 리소스를 해제합니다.
`swap`	두 `weak_ptr` 개체를 교환합니다.
`use_count`	개체 수를 `shared_ptr` 계산합니다.
연산자
`operator=`	소유하는 리소스를 대체합니다.

`element_type`

요소의 형식입니다.

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

설명

이 형식은 템플릿 매개 변수 T의 동의어입니다.

예시

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

소유권이 만료되었는지, 즉 참조된 개체가 삭제되었는지 테스트합니다.

bool expired() const noexcept;

설명

구성원 함수는 *this가 만료된 경우 true를 반환하고 그렇지 않으면 false를 반환합니다.

예시

// 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 공유하는 해당 리소스를 가져옵니다.

shared_ptr<T> lock() const noexcept;

설명

만료된 경우 *this 멤버 함수는 빈 shared_ptr 개체를 반환하고, 그렇지 않으면 가리키는 리소스를 소유하는 *this 개체를 반환 shared_ptr<T> 합니다. 의 원자성 실행에 expired() ? shared_ptr<T>() : shared_ptr<T>(*this)해당하는 값을 반환합니다.

예시

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

소유하는 리소스를 대체합니다.

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;

매개 변수

Other
공유 또는 약한 포인터 인수에 의해 제어되는 형식입니다.

ptr
복사할 약한 포인터 또는 공유 포인터입니다.

설명

운영자는 모두 현재 가리키는 리소스를 *this 해제하고 이름이 지정된 ptr 리소스의 소유권을 할당합니다 *this. 연산자가 실패하면 변경되지 않은 상태로 유지 *this 됩니다. 각 연산자에는 .에 해당하는 효과가 있습니다 weak_ptr(ptr).swap(*this).

예시

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

이 weak_ptr이 제공된 포인터 앞에 정렬(또는 보다 작음)되는 경우 true를 반환합니다.

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;

매개 변수

ptr
shared_ptr 또는 weak_ptr에 대한 lvalue 참조입니다.

설명

템플릿 멤버 함수는 앞에 ptr정렬된 경우 *this 반환 true 됩니다.

`reset`

소유 리소스를 해제합니다.

void reset() noexcept;

설명

멤버 함수는 가리키는 *this 리소스를 해제하고 빈 weak_ptr 개체로 변환합니다*this.

예시

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

두 weak_ptr 개체를 교환합니다.

void swap(weak_ptr& wp) noexcept;

특수화도 포함됩니다.

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

매개 변수

wp
교환할 취약 포인터입니다.

설명

이후에 swap는 원래 가리키는 *this 리소스가 가리키 wp고 원래 가리키는 wp 리소스는 다음을 가리 *this켰습니다. 함수는 두 리소스에 대한 참조 수를 변경하지 않으며 예외를 throw하지 않습니다. 템플릿 특수화의 효과는 다음과 같습니다 a.swap(b).

예시

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

공유 리소스를 소유하는 개체의 shared_ptr 수를 계산합니다.

long use_count() const noexcept;

설명

구성원 함수는 *this가 가리키는 리소스를 소유한 shared_ptr 개체의 수를 반환합니다.

예시

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

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;

매개 변수

Other
인수 공유/취약 포인터에 의해 제어되는 형식입니다. 와 호환element_type*되지 않는 한 Other* 이러한 생성자는 오버로드 확인에 참여하지 않습니다.

wp
복사할 취약 포인터입니다.

sp
복사할 공유 포인터입니다.

설명

기본 생성자는 빈 weak_ptr 개체를 생성합니다. 인수 포인터가 비어 있는 경우 인수를 사용하는 생성자는 각각 빈 weak_ptr 개체를 생성합니다. 그렇지 않으면 인수로 weak_ptr 명명된 리소스를 가리키는 개체를 생성합니다. 공유 개체의 참조 수는 변경되지 않습니다.

예시

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

weak_ptr을 삭제합니다.

~weak_ptr();

설명

소멸자가 이를 weak_ptr 제거하지만 저장된 포인터가 가리키는 개체의 참조 수에는 영향을 주지 않습니다.

참고 항목

헤더 파일 참조
<memory>
shared_ptr 클래스

weak_ptr 클래스

구문

매개 변수

설명

멤버

element_type

설명

예시

expired

설명

예시

lock

설명

예시

operator=

매개 변수

설명

예시

owner_before

매개 변수

설명

reset

설명

예시

swap

매개 변수

설명

예시

use_count

설명

예시

weak_ptr

매개 변수

설명

예시

~weak_ptr

설명

참고 항목

피드백

피드백

추가 리소스

`weak_ptr` 클래스

`element_type`

`expired`

`lock`

`operator=`

`owner_before`

`reset`

`swap`

`use_count`

`weak_ptr`

`~weak_ptr`