Smart Pointers, Modern Memory Management Techniques

• Smart pointers are a set of classes that
manage dynamically allocated objects,
providing automatic memory
management and helping to prevent
memory leaks.
Programming with Sikander : Smart Pointers 2

 auto_ptr
 unique_ptr
 shared_ptr
 weak_ptr
 These objects have the ability of taking ownership of
a pointer: once they take ownership they manage the
pointed object by becoming responsible for its
deletion at some point.

 This class template provides a garbage
collection facility for pointers, by allowing
pointers to have the elements they point to
automatically destroyed when the auto_ptr
object is itself destroyed.
 Its defined in memory header file.

 Observe if there is any memory leakage.

 auto_ptr objects have the peculiarity of taking
ownership of the pointers assigned to them:
 An auto_ptr object that has ownership over one
element is in charge of destroying the element it points
to and to deallocate the memory allocated to it when
itself is destroyed.
 Therefore, no two auto_ptr objects should own the
same element, since both would try to destruct them at
some point.
 When an assignment operation takes place between
two auto_ptr objects, ownership is transferred, which
means that the object losing ownership is set to no
longer point to the element (it is set to the null pointer).

 Auto_ptr is depreciated as should not be
used.
 The language has provided other smart
pointers.

 Improved version of auto_ptr.
 unique_ptr objects automatically delete the
object they manage as soon as they
themselves are destroyed, or as soon as their
value changes either by an assignment
operation or by an explicit call to
unique_ptr::reset.
 Unique_ptr does not contain copy
constructor and assignment operator.

 Pass by value invokes copy constructor
 Unique_ptr does not provide copy
constructor.

 Receiving by reference will not invoke
copy constructor.

 Move function transfers the ownership

 What is the type of p1?
 Is Memory Leaked?

Identify the type of p1.
Verify if there is memory leak

 make_unique returns an object of type unique_ptr and
new returns a pointer to the created object.
 unique_ptr<LongTypeName> up(new LongTypeName(args))
must mention LongTypeName twice, while
auto up = make_unique<LongTypeName>(args)
mentions it once.

 The shared_ptr type is designed for scenarios in which
more than one owner might have to manage the
lifetime of the object in memory.
 After you initialize a shared_ptr you can copy it, pass
it by value in function arguments, and assign it to
other shared_ptr instances.
 All the instances point to the same object, and share
access to one "control block" that increments and
decrements the reference count whenever a
new shared_ptr is added, goes out of scope, or is
reset.
 When the reference count reaches zero, the control
block deletes the memory resource and itself.

 std::weak_ptr is a smart pointer that holds a
non-owning ("weak") reference to an object
that is managed by std::shared_ptr.

 The weak_ptr objects that point to a resource do
not affect the resource's reference count.

 when the last shared_ptr object that manages that
resource is destroyed the resource will be freed,
even if there are weak_ptr objects pointing to that
resource.
 A weak_ptr object does not provide direct access
to the resource that it points to.
 Code that needs to use the resource does so
through a shared_ptr object that owns that
resource, created by calling the member function
lock.

THANKYOU

Smart Pointers, Modern Memory Management Techniques

More Related Content

Similar to Smart Pointers, Modern Memory Management Techniques

More from Mohammed Sikander

Recently uploaded

Smart Pointers, Modern Memory Management Techniques