std:: enable_shared_from_this

std::enable_shared_from_this 는 현재 std::shared_ptr pt 에 의해 관리되는 객체 t 가 pt 와 객체 t 의 소유권을 공유하는 추가 std::shared_ptr 인스턴스들( pt1 , pt2 등)을 안전하게 생성할 수 있도록 합니다.

std::enable_shared_from_this<T> 에서 공개적으로 상속받으면 T 타입에 shared_from_this 멤버 함수가 제공됩니다. T 타입의 객체 t 가 std:: shared_ptr < T > 인 pt 에 의해 관리되는 경우, T::shared_from_this 를 호출하면 t 와 pt 가 소유권을 공유하는 새로운 std:: shared_ptr < T > 를 반환합니다.

데이터 멤버

멤버 함수

참고 사항

std::shared_ptr 의 생성자들은 명확하고 접근 가능한(즉, public 상속이 필수적임) enable_shared_from_this 베이스의 존재를 감지하고, 새로 생성된 std::shared_ptr 을 이미 활성 std::shared_ptr 에 의해 소유되지 않은 경우 weak_this 에 할당합니다. 이미 다른 std::shared_ptr 에 의해 관리되는 객체에 대한 std::shared_ptr 을 생성하는 경우 weak_this 를 참조하지 않으므로 정의되지 않은 동작을 초래합니다.

shared_from_this 는 사전에 공유된 객체, 즉 std:: shared_ptr < T > 에 의해 관리되는 객체에서만 호출이 허용됩니다. 그렇지 않으면 std::bad_weak_ptr 이 발생합니다 (기본 생성된 weak_this 로부터의 std::shared_ptr 생성자에 의해).

enable_shared_from_this 는 std:: shared_ptr < T > ( this ) 와 같은 표현식에 대한 안전한 대안을 제공합니다. 이러한 표현식은 서로를 인식하지 못하는 여러 소유자에 의해 this 가 여러 번 파괴될 가능성이 있습니다 (아래 예제 참조).

예제

#include <iostream>
#include <memory>
class Good : public std::enable_shared_from_this<Good>
{
public:
    std::shared_ptr<Good> getptr()
    {
        return shared_from_this();
    }
};
class Best : public std::enable_shared_from_this<Best>
{
    struct Private{ explicit Private() = default; };
public:
    // 생성자는 이 클래스에서만 사용 가능
    Best(Private) {}
    // 다른 모든 사용자는 이 팩토리 함수를 사용해야 함
    // 따라서 모든 Best 객체는 shared_ptr에 포함됨
    static std::shared_ptr<Best> create()
    {
        return std::make_shared<Best>(Private());
    }
    std::shared_ptr<Best> getptr()
    {
        return shared_from_this();
    }
};
struct Bad
{
    std::shared_ptr<Bad> getptr()
    {
        return std::shared_ptr<Bad>(this);
    }
    ~Bad() { std::cout << "Bad::~Bad() called\n"; }
};
void testGood()
{
    // Good: 두 shared_ptr이 동일한 객체를 공유함
    std::shared_ptr<Good> good0 = std::make_shared<Good>();
    std::shared_ptr<Good> good1 = good0->getptr();
    std::cout << "good1.use_count() = " << good1.use_count() << '\n';
}
void misuseGood()
{
    // Bad: std::shared_ptr이 호출자를 소유하지 않은 상태에서 shared_from_this가 호출됨
    try
    {
        Good not_so_good;
        std::shared_ptr<Good> gp1 = not_so_good.getptr();
    }
    catch (std::bad_weak_ptr& e)
    {
        // 정의되지 않은 동작 (C++17 이전) 및 std::bad_weak_ptr 예외 발생 (C++17 이후)
        std::cout << e.what() << '\n';
    }
}
void testBest()
{
    // Best: 동일하지만 스택 할당이 불가능함:
    std::shared_ptr<Best> best0 = Best::create();
    std::shared_ptr<Best> best1 = best0->getptr();
    std::cout << "best1.use_count() = " << best1.use_count() << '\n';
    // Best stackBest; // <- Best::Best()가 private이므로 컴파일되지 않음.
}
void testBad()
{
    // Bad: 각 shared_ptr이 객체의 유일한 소유자라고 생각함
    std::shared_ptr<Bad> bad0 = std::make_shared<Bad>();
    std::shared_ptr<Bad> bad1 = bad0->getptr();
    std::cout << "bad1.use_count() = " << bad1.use_count() << '\n';
} // UB: Bad의 이중 삭제
int main()
{
    testGood();
    misuseGood();
    testBest();
    testBad();
}

good1.use_count() = 2
bad_weak_ptr
best1.use_count() = 2
bad1.use_count() = 1
Bad::~Bad() 호출됨
Bad::~Bad() 호출됨
*** glibc 감지됨 *** ./test: 이중 해제 또는 손상

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

참고 항목