- Don’t use raw pointers as class members; that requires managing object life time and manually avoiding dangling pointers
- Use smart pointers instead of raw pointers
- Don’t use object references as class members as that makes objects of the class non-assignable (which means you cannot store said objects in standard C++ containers)
- Using raw pointers and object references to objects stored in standard C++ containers is problematic or impossible. Objects in containers can be relocated (addresses can change) rendering raw pointers and object references invalid.
- Best (only feasible?) option is to store
std::shared_ptr of the dynamically allocated object in the container.
std::shared_ptr is reference counted std::weak_ptr is not- Use
std::make_shared to create an std::shared_ptr to a dynamically created object instance or use std::shared_ptr(new T())
- Only way to access members via
std::weak_ptr is by calling std::weak_ptr::lock which returns an std::shared_ptr or 0
- To create an
std::weak_ptr from the this pointer, the class must first derive from std::enable_shared_from_this and then call the shared_from_this function to get an std::shared_ptr pointing to the object. The object in question must be “owned” by an std::shared_ptr or else undefined behaviour results. Also, shared_from_this must not be called from a constructor since the object is yet to be reference counted (i.e. object is not yet “owned” by an std::shared_ptr)
- As a result of the previous point, it helps to ensure that objects can only be created via
std::shared_ptr by using a public static create function (which returns objects “owned” by an std::shared_ptr) and making constructors private. Note that when constructors are made private, you can no longer use std::make_shared to create a shared pointer. You must use std::shared_ptr(new T()) in this case.
Modern C++ Object Relationships