shared_ptr 클래스

동적으로 할당된 개체 주위에 참조 횟수가 계산되는 스마트 포인터를 래핑합니다.

template<class Ty>
   class shared_ptr {
public:
    typedef Ty element_type;

    shared_ptr();
    shared_ptr(nullptr_t); 
    shared_ptr(const shared_ptr& sp);
    shared_ptr(shared_ptr&& sp);
    template<class Other>
        explicit shared_ptr(Other * ptr);
    template<class Other, class D>
        shared_ptr(Other * ptr, D dtor);
    template<class D>
        shared_ptr(nullptr_t, D dtor);
    template<class Other, class D, class A>
        shared_ptr(Other *ptr, D dtor, A alloc);
    template<class D, class A>
        shared_ptr(nullptr_t, D dtor, A alloc);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp);
    template<class Other>
        shared_ptr(const shared_ptr<Other>&& sp);
    template<class Other>
        explicit shared_ptr(const weak_ptr<Other>& wp);
    template<class Other>
        shared_ptr(auto_ptr<Other>& ap);
    template<class Other, class D>
        shared_ptr(unique_ptr<Other, D>&& up);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
    ~shared_ptr();
    shared_ptr& operator=(const shared_ptr& sp);
    template<class Other> 
        shared_ptr& operator=(const shared_ptr<Other>& sp);
    shared_ptr& operator=(shared_ptr&& sp);
    template<class Other> 
        shared_ptr& operator=(shared_ptr<Other>&& sp);
    template<class Other> 
        shared_ptr& operator=(auto_ptr< Other >&& ap);
    template <class Other, class D> 
        shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
    template <class Other, class D>
        shared_ptr& operator=(unique_ptr<Other, D>&& up);
    void swap(shared_ptr& sp);
    void reset();
    template<class Other>
        void reset(Other *ptr);
    template<class Other, class D>
        void reset(Other *ptr, D dtor);
    template<class Other, class D, class A>
        void reset(Other *ptr, D dtor, A alloc);
    Ty *get() const;
    Ty& operator*() const;
    Ty *operator->() const;
    long use_count() const;
    bool unique() const;
    operator bool() const;

    template<class Other>
        bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other>
        bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty> 
        D* get_deleter(shared_ptr<Ty> const& ptr);
};

매개 변수

• Ty
  공유 포인터에 제어되는 형식입니다.

• Other
  인수 포인터에 제어되는 형식입니다.

• ptr
  복사 포인터입니다.

• D
  제거자 형식입니다.

• A
  할당자 형식입니다.

• dtor
  제거자입니다.

• alloc
  할당자입니다.

• sp
  복사하거나 이동하기 위한 스마트 포인터입니다.

• wp
  복사하거나 이동하기 위한 약한 포인터입니다.

• ap
  복사하거나 이동하기 위한 자동 포인터입니다.

• up
  이동하기 위한 고유 포인터입니다.

설명

템플릿 클래스는 리소스 관리 참조 횟수를 사용하는 개체를 설명합니다. A shared_ptr 개체는 null 포인터를 소유하고 있는 리소스에 대한 포인터를 효과적으로 가지고 있습니다. 리소스는 하나 이상의 shared_ptr 개체를 소유할 수 있습니다. 특정 리소스를 소유한 마지막 shared_ptr 개체가 소멸되었을 때, 리소스는 해제됩니다.

A shared_ptr 재할당 되거나 다시 설정 될 때 리소스 소유를 중지합니다.

템플릿 인수 Ty 는 특정 멤버 함수에 대한 언급을 제외하고는 불완전한 형식이 될 수 있습니다.

shared_ptr<Ty> 개체가 G* 형식의 리소스 포인터 또는 shared_ptr<G> 으로부터 생성될 경우, G* 포인터 형식은 Ty* 로 변환될 수 있어야 합니다. 그렇지 않은 경우, 코드는 컴파일되지 않습니다. 예를 들면 다음과 같습니다.

class F {};
class G : public F {};

#include <memory>

using namespace std;

shared_ptr<G> sp0(new G);   // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0);     // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G);   // okay, G* convertible to F*
shared_ptr<F> sp3(sp0);     // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2);     // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2);   // error, template parameter int and argument shared_ptr<F>

A shared_ptr 개체가 리소스를 소유할 때:

• 해당 리소스에 대 한 포인터를 사용하여 생성 된 경우

• 해당 리소스를 소유하는 shared_ptr 개체로부터 생성된 경우

• 해당 리소스를 가리키는 weak_ptr 클래스 개체로부터 생성된 경우

• 해당 리소스의 소유권을 shared_ptr::operator= 또는 shared_ptr::reset 멤버함수를 호출하여 재설정하거나 할당된 경우

리소스를 소유하는 shared_ptr 개체는 제어 블록을 공유합니다. 제어 블록은 다음을 보유합니다:

• 리소스를 소유하는 shared_ptr 개체의 수

• 리소스를 가리키는 weak_ptr 개체의 수

• 해당 리소스에 대한 제거자

• 제어 블록에 대한 사용자 지정 할당자.

널 포인터를 사용하여 초기화된 shared_ptr 개체는 제어 블록을 가지고 있으며 비어있지 않습니다. shared_ptr 개체가 리소스를 해제한 후에, 해당 리소스를 더 이상 소유하지 않습니다. weak_ptr 개체가 리소스를 해제한 후에, 해당 리소스를 더 이상 가리키지 않습니다.

리소스를 소유한 shared_ptr 개체의 수가 0이 되었을 때, 리소스의 소유권을 처음 만든 방법에 따라 제거자에 주소를 넘기거나 삭제함으로써 리소스는 해제됩니다. 리소스를 소유한 shared_ptr 개체나 해당 리소스를 가리키는 weak_ptr 개체의 수가 0이 되었을 때, 제어 블록에 대한 사용자 지정 할당자를 사용하여 제어 블록은 해제됩니다.

빈 shared_ptr 개체는 리소스를 소유하지 않고, 제어 블록이 없습니다.

제거자는 operator() 멤버 함수를 가진 함수입니다. 이 형식은 복사본 생성이 가능하고, 복사 생성자 및 소멸자는 예외를 throw 하지 않아야 합니다. 삭제될 개체의 매개 변수를 받아들입니다.

일부 함수는 shared_ptr<Ty> 또는 weak_ptr<Ty> 개체 결과의 속성을 정의하는 인수 목록을 가집니다. 여러 가지 방법으로 인수 목록을 지정할 수 있습니다.

인수 없음 -- 결과 개체가 빈 shared_ptr 개체 또는 빈 weak_ptr 개체입니다.

ptr-- 리소스를 관리에 대한 Other* 형식의 포인터입니다. Ty은 완전한 형식이어야 합니다. 함수가 실패 한 경우 (제어 블록을 할당할 수 없기 때문입니다), delete ptr 식을 평가합니다.

ptr, dtor -- 관리되는 리소스 및 해당 리소스 제거자에 대한 Other* 형식의 포인터입니다. 함수가 실패 한 경우 (제어 블록을 할당할 수 없기 때문에), 제대로 정의되어 있어야 하는 dtor(ptr) 를 호출합니다.

ptr, dtor, alloc-- 관리되는 리소스 및 해당 리소스 제거자, 그리고 할당하고 해제해야 하는 모든 저장소를 관리하는 할당자에 대한 Other* 형식의 포인터입니다. 함수가 실패한 경우 (제어 블록을 할당할 수 없기 때문에), 제대로 정의되어 있어야 하는 dtor(ptr) 를 호출합니다.

sp -- 관리되는 리소스를 소유한 shared_ptr<Other> 개체입니다.

wp-- 관리되는 리소스를 가리키는 weak_ptr<Other> 개체입니다.

ap -- 관리되는 리소스에 대한 포인터를 보유하고 있는 auto_ptr<Other> 개체입니다. 함수가 성공하면 ap.release() 을 호출하고, 그렇지 않으면 ap 는 변경되지 않습니다.

항상 Other* 형식의 포인터는 Ty* 으로 변환될 수 있어야 합니다.

스레드로부터의 안전성

다중 스레드는 개체들이 소유권 공유를 복사할 때에도, 동시에 다른 shared_ptr 개체를 읽고 쓸 수 있습니다.

멤버

생성자

메서드

연산자

요구 사항

헤더 <memory>

네임스페이스: std

참고 항목

참조

weak_ptr 클래스

C++ 표준 라이브러리의 스레드 보안

기타 리소스

<memory> 멤버