검증 펑터의 대상 개체

Question

나는 클래스 bar의 방법 중 하나에 멤버 함수 포인터를 받아 클래스 foo을 가지고 있지만 foo이 펑터 이전 bar의 존재를 확인 할 수있는 방법이보다 클래스 바는 짧은 수명을 가질 수있다 실행 중입니까?

현재 std::function의 bool operator을 사용하려고합니다.

class Foo 
{ 
public: 
    void Foo::SetCallback(std::function< void(void) > cb) 
    { 
     _cb = cb; // My Bar class will call this to assign a Bar member function pointer to Foo's _cb member variable 
    } 
    void Foo::CallCallback() 
    { 
     if(_cb) _cb(); // This evaluates to true even if the original bar object has been destroyed 
     //I want this callback to only execute if the bar object exists 
    } 
private: 
    std::function< void(void) > _cb; 
}; 
class Bar 
{ 
public: 
    Bar(Foo* _foo) 
    { 
     _foo->SetCallback(std::bind(&myCalledbackFunc, this); 
    } 
    void myCalledbackFunc() 
    { 
     //do stuff 
    } 
}; 

Answer 1

은 객체의 파괴에 제로되지 않습니다. 따라서 Silvester Seredi은 그의 답변에서 참조하는 객체가 파괴되었는지 여부를 알 수있는 유일한 방법은 포인터가 자동 포인터 소유 객체를 참조하는 것입니다. 또한 오브젝트가 내부적으로 소유 될 수 없으므로 오브젝트가 본질적으로 오브젝트가 손상되었는지에 대한 표시기를 제공 할 수 없습니다.

따라서 유일한 해결책은 functor를 가지고있는 클래스에, perreal에서 제안한 것처럼, functor가 멤버를 참조하는 클래스가 파기되었을 때 유효하지 않음을 알리는 것입니다. 이것은 다중 스레드에 안전하지 않습니다.

class Foo 
{ 
public: 
    void SetCallback(std::function< void(void) > cb) 
    { 
     _cb = cb; 
    } 
    void UnSetCallback() 
    { 
     _cb = std::function< void(void) >(); 
    } 
    void CallCallback() 
    { 
     if(_cb) _cb(); 
    } 
private: 
    std::function< void(void) > _cb; 
}; 
class Bar 
{ 
public: 
    Bar(Foo* foo) : _foo(foo) 
    { 
     _foo->SetCallback(std::bind(&myCalledbackFunc, this); 
    } 
    ~Bar() 
    { 
     _foo->UnSetCallback(); 
    } 
    void myCalledbackFunc() 
    { 
     //do stuff 
    } 
private: 
    Foo _foo; 
}; 

Answer 2

내가 콜백 객체가 소멸 될 때 푸 알려하는 방법 어떤 간단한 방법을 생각할 수 없다,하지만 당신이 정말로 개체가 살아 있는지 여부를 푸 클래스에서 확인하고 싶은 경우, 나는를 사용하십시오

약한 곳은 길을 따라 어딘가에 있습니다.

class Bar; 
class Foo 
{ 
public: 
    void Foo::SetCallback(std::function< void(void) > cb) 
    { 
     _cb = cb; 
    } 

    void Foo::RegisterBar(std::weak_ptr<Bar> inbarPtr) 
    { 
     barRef = inbarPtr; 
    } 

    void Foo::CallCallback() 
    { 
     if(_cb && !barRef.expired()) _cb(); 
    } 

private: 
    std::function< void(void) > _cb; 
    std::weak_ptr<Bar> barRef; 
}; 

class Bar 
{ 
public: 
    Bar(Foo* _foo) 
    { 
     _foo->SetCallback(std::bind(&Bar::myCalledbackFunc, this)); 
    } 
    void myCalledbackFunc() 
    { 
     //do stuff 
    } 
}; 

int main() 
{ 
    Foo fooInstace; 
    std::shared_ptr<Bar> barInstance = std::make_shared<Bar>(&fooInstace); 
    fooInstace.RegisterBar(barInstance); 
    return 0; 
} 

당신이 만약 정말로 : 당신이 new을 통해 줄을 만드는 경우 대신 make_shared를 통해 인스턴스를 만들 수 있습니다 당신은 같은 것을 할 것 (추가 비용은 바 인스턴스의 모든 건설 후 하나의 함수 호출) 단지 바 클래스에 대한 변경 사항에, 당신은 빈 사용자 정의 Deleter가와 못생긴, 추한 해킹을 사용할 수 있습니다 주장 해 :

객체에서 사용하는 메모리 ++ C에서

class Bar; 
class Foo 
{ 
public: 
    void Foo::SetCallback(std::function< void(void) > cb , std::weak_ptr<Bar> inbarPtr) 
    { 
    _cb = cb; 
    barRef = inbarPtr; 
    } 
    void Foo::CallCallback() 
    { 
    if(_cb && !barRef.expired()) _cb(); 
    } 
private: 
    std::function< void(void) > _cb; 
    std::weak_ptr<Bar> barRef; 
}; 


class Bar 
{ 
    std::shared_ptr<Bar> selfPtr; 
public: 
    Bar(Foo* _foo) 
    { 
    selfPtr = std::shared_ptr<Bar>(this, Bar::EmptyDeleter); 
    _foo->SetCallback(std::bind(&Bar::myCalledbackFunc, this), selfPtr); 
    } 
    void myCalledbackFunc() 
    { 
    //do stuff 
    } 
protected: 
    static void EmptyDeleter(Bar*) 
    { 
    } 
};