우리는 언제 std :: enable_shared_from_this

Question

을 사용해야합니까? std::enable_shared_from_this 양식 this link을 방금 알았습니다.
그러나 아래 코드를 읽은 후에는 언제 사용해야할지 모르겠습니다. getptr()를 호출하기 전에 기존 shared_ptr이 없기 때문에 위의

try { 
     Good not_so_good; 
     std::shared_ptr<Good> gp1 = not_so_good.getptr(); 
    } catch(std::bad_weak_ptr& e) { 
     // undefined behavior (until C++17) and std::bad_weak_ptr thrown (since C++17) 
     std::cout << e.what() << '\n';  
    } 

코드는 "너무 좋지 않다"입니다. 그래서 좋은 일이되어야합니다 :

std::shared_ptr<Good> gp1 = std::make_shared<Good>(); // having a shared_ptr at the beginning 
std::shared_ptr<Good> gp2 = gp1->getptr(); 

을 그러나, 나는 이미이 같은하지 난 단지 코드를 할 이유 shared_ptr 개체, 한 경우 : 나는 모든 std::enable_shared_from_this을 필요로하지 않는다는 것을 의미 std::shared_ptr<Good> gp2 = gp1;을. std::enable_shared_from_this를 사용하여 내 의견으로는

, 우리는 the double-delete problem를 방지 할 수 있도록 하나 이상의 shared_ptr 객체가 같은 제어 블록이 있는지 확인하는 것입니다. 그러나 내가 처음에 shared_ptr을 만들 것을 상기시켜야한다면. 왜 그냥 원시 포인터를 사용하는 대신 shared_ptr 개체를 사용하여 새로운 개체를 만들 것을 상기시키지 않습니까?

Answer 1

std::enable_shared_from_this<T>이 유용 할 때 힌트가 있습니다. 요청에 따라 개체를 생성 할 때 개체 자체에 대한 포인터를 반환해야 할 수 있습니다. 결과가 std::shared_ptr<T>이면 일반적으로 액세스 할 수없는 멤버 함수 내에서 그러한 포인터를 반환해야합니다. std::shared_ptr<T>

std::enable_shared_from_this<T>에서 파생 된 것은 T 유형의 포인터 만 주어진 std::shared_ptr<T>을 보유 할 수있는 방법을 제공합니다. 그러나 개체가 이미 std::shared_ptr<T>를 통해 관리되어 있다고 가정 않습니다 이렇게와 객체가 스택에 할당되어있는 경우는 신체 상해를 만들 것입니다 : 현실적인 시나리오에서

struct S: std::enable_shared_from_this<S> { 
    std::shared_ptr<S> get_object() { 
     return this->shared_from_this(); 
    }; 
} 

int main() { 
    std::shared_ptr<S> ptr1 = std::make_shared<S>(); 
    std::shared_ptr<S> ptr2 = ptr1->get_object(); 
    // ... 
} 

아마 어떤 조건이 이는 std::shared_ptr<T>을 아래 현재 오브젝트에 대한 값이 리턴됩니다.

Answer 2

불투명 포인터와 같은 템플릿 std::shared_ptr<T>을 사용할 수없는 유스 케이스가 있습니다. 이 경우

, 그것은이있는 것이 유용 : some_file.cpp some_other.c에서

struct A : std::enable_shared_from_this<A> {}; 

extern "C" void f_c(A*); 
extern "C" void f_cpp(A* a) { 
    std::shared_ptr<A> shared_a = a->shared_from_this(); 
    // work with operation requires shared_ptr 
} 

int main() 
{ 
    std::shared_ptr<A> a = std::make_shared<A>(); 
    f_c(a.get()); 
} 

---

에서

struct A; 
void f_cpp(struct A* a); 
void f_c(struct A* a) { 
    f_cpp(a); 
} 

Answer 3

은 이제 나는를 표현하고 싶은 말은하자 계산 트리. 표현식에 대한 두 개의 포인터를 사용하여 표현식에서 파생되는 클래스로 표현 된 표현식을 추가함으로써 표현식을 재귀 적으로 평가할 수 있습니다. 그러나 평가를 어딘가에 끝내야하므로 숫자를 평가 해 보겠습니다.

class Number; 

class Expression : public std::enable_shared_from_this<Expression> 
{ 
public: 
    virtual std::shared_ptr<Number> evaluate() = 0; 
    virtual ~Expression() {} 
}; 

class Number : public Expression 
{ 
    int x; 
public: 
    int value() const { return x; } 
    std::shared_ptr<Number> evaluate() override 
    { 
     return std::static_pointer_cast<Number>(shared_from_this()); 
    } 
    Number(int x) : x(x) {} 
}; 

class Addition : public Expression 
{ 
    std::shared_ptr<Expression> left; 
    std::shared_ptr<Expression> right; 
public: 
    std::shared_ptr<Number> evaluate() override 
    { 
     int l = left->evaluate()->value(); 
     int r = right->evaluate()->value(); 
     return std::make_shared<Number>(l + r); 
    } 
    Addition(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) : 
     left(left), 
     right(right) 
    { 

    } 
}; 

는 이중 삭제가 발생합니다 때문에 return std::shared_ptr<Number>(this);와 Number::evaluate()을 구현의 "명백한"방법이 파괴되는 것을

Live on Coliru

주

.