C++ Destruction Dependencies - c++

Question

I have a C++ class that needs to track resource usage, and when the last instance referencing the specific resource is destructed, the resource must be released. Due to the nature of how this resource can be acquired by multiple different objects (and not just through a copy / move constructor), I've had to implement my own reference tracking.
This reference tracking works great with very little performance hit, but when I started adding threading, I had to add a critical section to guard accesses to the reference counting structure. The critical section is a static member of the class that uses it. This works fine until the process begins exiting, and it's time for everything's destructor to be called.
What's happening is that the critical section's destructor (which calls DeleteCriticalSection) is being called before the last destructor of my objects. The result is that I'm stuck with either possible race conditions on my reference counter or a crash from trying to enter an invalid critical section.
These objects have a clear dependency on this critical section, and I don't see a great way to prevent it from being destroyed until the last object is gone. My thinking is to change the critical section from a static member to a std::shared_ptr<CriticalSection> belonging to each instance of the class, but that seems like it'd have an unnecessary performance hit.
Is there some other way to outline this dependency? Or is there a better way to do what I'm trying to do without a need for this dependency in the first place?
EDIT: To be clear, I tried using std::shared_ptr to handle reference tracking. Unfortunately, that doesn't work. Here's a trivialized example of how it causes issues.
Object Get(){
Object o1{ GetResourceIdentifier(3) };
Object o2{ o1 }; // Copy constructor
Object o3{ GetResourceIdentifier(3) };
return o3;
}
void main(){
auto test{ Get() };
test.DoStuff();
}
Necessarily, when an object is instantiated, it will just open the same resource if it's already open. So o1, o2, and o3 will all refer to the same underlying resource in this example. But with std::shared_ptr, when Get returns, the shared pointer that o1 and o2 have will think that there are no references left and release the resource. Unfortunately, since o3 refers to the same resource, its resource also gets freed here, meaning the call to DoStuff will go awry.
If you'd like to see the actual code (file is rather large), the source is here and the header is here

Answer 1

If I understand your use case can use shared_ptr, but the trick is to store weak_ptrs, otherwise your resource will not be freed until the end of the program:
struct Resource
{
int id;
Resource(int id):id{id}{};
~Resource() { std::cout << "~" << id << std::endl; }
auto foo() { std::cout << "foo" << id << std::endl; }
};
std::shared_ptr<Resource> get_resource(int resource_id)
{
static std::mutex mutex{};
static std::unordered_map<int, std::weak_ptr<Resource>> resource_map{};
std::scoped_lock lock{mutex};
auto& weak = resource_map[resource_id];
if (!weak.lock())
{
auto shared = std::make_shared<Resource>(resource_id);
weak = shared;
return shared;
}
return weak.lock();
}
This works as follows: When request a resource i
if there isn't any resource i with active owners: creates a new resource, returns a new shared_ptr and stores a weak_ptr to it
if there is a resource i with active owners returns a new share_ptr to it
A resource i:
will be created on the first get_resource(i) call
will be deleted once there are no more owners to it (get_resource doesn't hold owners)
once deleted a new resource will be recreated on the next get_resource(i) call
there will never be more than 1 resources i at the same time
This seems to work, but be advised I have done only summary testing:
auto test()
{
auto r0 = get_resource(1);
auto r1 = get_resource(24);
auto r2 = r1;
auto r3 = get_resource(24);
return r3;
}
int main()
{
auto r = test();
r->foo();
}
Outputs
~1
foo24
~24