C++ pass this, and determine when it is destroyed in different class - c++

Question

I'm working on some code, which has a model similar to the following (it is a small part of a much larger application). In short, one of the classes (Class B) registers itself with another class (Class A) by passing this. Class B gets destroyed at some point in the larger application. Class A has a method invoked which depends on B and B is invoked after being destroyed (after doing a nullptr check). Rewriting this application to not have this pattern is not really an option. In A::GetVal() how do I correctly determine if B has already been destroyed? I can change the method signature for RegisterB(), but ultimately B needs to register itself with A and B can be destroyed at any time.
Classes.h:
#ifndef CLASSES_H
#define CLASSES_H
#pragma once
#include <iostream>
class B;
class A
{
private:
B* m_b;
int m_val;
public:
A(int val) : m_val(val) {}
int GetVal();
void RegisterB(B* b) { m_b = b; }
};
class B
{
private:
int m_val;
public:
B(int val) : m_val(val) {}
int GetVal() { return m_val; }
void RegisterWithA(A* a) { a->RegisterB(this); }
};
#endif
Classes.cpp:
#include "stdafx.h"
#include "Classes.h"
int A::GetVal()
{
if (m_b != nullptr)
{
m_b->GetVal(); // How do I prevent this branch from getting called?
}
else
{
return -1;
}
}
And main:
#include "stdafx.h"
#include "Classes.h"
int _tmain(int argc, _TCHAR* argv[])
{
A* a = new A(-1);
B* b = new B(1);
b->RegisterWithA(a);
delete b;
int result = a->GetVal();
delete a;
return 0;
}

Answer 1

You can use std::shared_ptr<> in conjunction with std::weak_ptr<> to handle this.
#include <iostream>
#include <memory>
using namespace std;
class B;
class A
{
private:
std::weak_ptr<B> m_b;
int m_val;
public:
A(int val) : m_val(val) {}
int GetVal();
void RegisterB(std::shared_ptr<B> b) { m_b = b; }
};
class B : public std::enable_shared_from_this<B>
{
private:
int m_val;
public:
B(int val) : m_val(val) {}
int GetVal() { return m_val; }
void RegisterWithA(A* a) { a->RegisterB(shared_from_this()); }
};
int A::GetVal()
{
if(auto b = m_b.lock())
{
m_val = b->GetVal();
}
return m_val;
}
int main()
{
auto a = std::make_shared<A>(-1);
auto b = std::make_shared<B>(1);
b->RegisterWithA(a.get());
b.reset();
int result = a->GetVal();
std::cout << result << '\n';
return 0;
}

Answer 2

You should rethink your design. Why are you using heap allocation of objects when it would be perfectly acceptable in this situation to have them on stack? Why are you not using inheritance and having B inherit from A? This whole quandry goes away when you don't force yourself to do unnecessary things.
If, for some reason you're forced to have have disparate heap-based objects then do something like wrap the allocated instance into a unique_ptr<> and pass the instance around or alternatively, as stated in Chad's answer, wrap it into a shared_ptr<> and maintain a weak_ptr<> reference for usage.

Answer 3

Unless the use of weak_ptr can be proven to be minimal and local to classes A and B (in that case it will be surely the recommended modification), it seems to me that a localized and minimal modification could be:
add to class A some unregisterB method (sets m_b to null)
maintain in B a set of A pointers. One sole pointer will do if the association is not many-to-one, that is, if an instance of B cannot be registered within many instances of A.
In B::~B, call unregisterB on all the A's in the set.
in B::RegisterWithA, add that instance (pointer) of A to the list.
The advantage here is that no other modifications are required in the application, only in the classes A and B.