trjhtr

I created a little singleton-like class that gets deleted when there is no reference to it anymore (so its lifetime shall be somewhat predictable). I aimed to make it thread-safe.

#include <memory>
#include <mutex>

template< typename t_type >
struct shared_instance

 static std::shared_ptr< t_type > get_shared_instance()
 
 static std::weak_ptr< t_type > weak;
 static std::mutex mutex;

 auto result = weak.lock();
 if( nullptr == result )
 
 std::unique_lock< std::mutex > lock mutex ;

 result = weak.lock();
 if( nullptr != result )
 
 return result;
 

 result = std::make_shared< t_type >();
 weak = result;
 
 return result;
 
;

template< typename t >
struct context 
 
 context() 
 : instance shared_instance< t >::get_shared_instance() 
 

private: std::shared_ptr< t > instance;
;

I would be glad if you could comment on the implementation itself and how I could tackle non-default-constructible objects (I know of perfect forwarding and variadic templates but I have not found an elegant way to evaluate them lazily).

Non-Default Constructors:

Adding support for non-default constructible objects in a "lazy" fashion, could be done by adding a factory function of std::function<std::shared_ptr< t_type >()>.

template< typename t_type >
struct shared_instance

 using t_factory = std::function<std::shared_ptr< t_type >()>;

 static t_factory factory; // MUST be set before calling get_shared_instance

 static std::shared_ptr< t_type > get_shared_instance()
 
 ...


 assert(factory); // or throw, or return empty shared_ptr

 result = factory(); // instead of make_shared

 ...
 

;

// and define the static member...
template< typename t_type >
typename shared_instance< t_type >::t_factory shared_instance< t_type >::factory;


...

int main()

 context<int> c; // not ok... haven't set factory yet!

 // do this before any call to get_shared_instance
 shared_instance<int>::factory = () return std::make_shared<int>(5); ; // store things in the lambda by value, not reference...

 context<int> c; // ok

I'm not sure this counts as elegant though, as it gives you a two-step initialization process. This could be fixed by recognising the shared_instance itself as a kind of factory, making its contents non-static, and passing it into the contexts:

template< typename t >
struct context

 context(instance_provider< t >& provider): // now it can't be created unless this exists...
 instance provider.get_shared_instance() 
 

private:

 std::shared_ptr< t > instance;
;

int main()

 auto provider = instance_provider<int>( () return std::make_shared<int>(5); );

 context<int> c(provider);

Further Considerations:

Does the C library you're using say anything about context lifetime itself? (e.g. Winsock reference counts calls to WSAStartup() and WSACleanup() internally, so as long as the calls are paired properly the C library handles cleaning up)

The main feature that this shared_instance class seems to provide is destroying The Instance promptly after the last context is destroyed. RAII itself could be achieved by just storing a unique pointer over the maximum possible lifetime of any contexts, which would be simpler. Is this prompt destruction actually important?

If not, then it's just a singleton, which we either live with, or do the work to pass a pointer or reference to the thing you need where it needs to be.