약한 포인터에 대한 Dr Dobbs 기사 에서이 예제를 이해하기 쉽다고 생각합니다 (출처 : http://drdobbs.com/cpp/184402026 ).

… 이와 같은 코드는 올바르게 작동하지 않습니다.

int *ip = new int;
shared_ptr<int> sp1(ip);
shared_ptr<int> sp2(ip);

둘 중 어느 것도 shared_ptr 개체 다른 개체에 대해 알지 못하므로 개체가 모두 파괴되면 리소스를 해제하려고합니다. 일반적으로 문제가 발생합니다.

마찬가지로 멤버 함수에 호출되는 shared_ptr객체를 소유 한 객체가 필요한 경우 즉시 객체를 만들 수 없습니다.

struct S
{
  shared_ptr<S> dangerous()
  {
     return shared_ptr<S>(this);   // don't do this!
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->dangerous();
   return 0;
}

이 코드는 이전 예제와 같은 문제가 있지만 더 미묘한 형식입니다. 그것이 구축 될 때, shared_ptr 객체 sp1는 새로 할당 된 리소스를 소유합니다. 멤버 함수 내부의 코드 S::dangerous는 해당 shared_ptr객체 에 대해 알지 못 하므로 shared_ptr반환 되는 객체는와 다릅니다 sp1. 새 shared_ptr객체를 복사 sp2해도 도움이되지 않습니다. 때 sp2범위를 벗어나, 그것은 리소스를 분리 한 경우 것이다 sp1범위를 벗어나, 다시 리소스를 해제합니다.

이 문제를 피하는 방법은 클래스 템플릿을 사용하는 것 enable_shared_from_this입니다. 템플리트는 하나의 템플리트 유형 인수를 사용하는데, 이는 관리 자원을 정의하는 클래스의 이름입니다. 해당 클래스는 템플릿에서 공개적으로 파생되어야합니다. 이처럼 :

struct S : enable_shared_from_this<S>
{
  shared_ptr<S> not_dangerous()
  {
    return shared_from_this();
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->not_dangerous();
   return 0;
}

이 작업을 수행 할 때 호출 shared_from_this하는 shared_ptr객체 는 객체 가 소유해야 합니다. 작동하지 않습니다.

int main()
{
   S *p = new S;
   shared_ptr<S> sp2 = p->not_dangerous();     // don't do this
}

답변

class Node {
public:
    Node* getParent const() {
        if (m_parent) {
            return m_parent;
        } else {
            return this;
        }
    }

private:

    Node * m_parent = nullptr;
};           

class Node : std::enable_shared_from_this<Node> {
public:
    std::shared_ptr<Node> getParent const() {
        std::shared_ptr<Node> parent = m_parent.lock();
        if (parent) {
            return parent;
        } else {
            return shared_from_this();
        }
    }

private:

    std::weak_ptr<Node> m_parent;
};           

shared_ptr<Y> Y::f()
{
    return m_stub.lock();
}