Smart Pointers

Dumb Pointers Pointers Necessary Dynamic memory Sharing memory

Dumb Pointers Pointers Necessary But they are tricky Dynamic memory Sharing memory But they are tricky Memory leaks Bad pointers

References References : safer pointers C++ : Non-nullable

References Java : All objects are on heap Stack has Numeric Variables References References are nullable Cannot delete memory

References Python Everything is a reference… even numbers x = 1 1 x

References Python x = 1 x = 2 Everything is a reference… even numbers

References Python x = 1 x = 2 y = x Everything is a reference… even numbers x = 1 x = 2 y = x 1 x 2 y

References Python x = 1 x = 2 y = x x = 4 Everything is a reference… even numbers x = 1 x = 2 y = x x = 4 1 x 2 y 4

References Python x = 1 x = 2 y = x x = 4 x = x + 1 Everything is a reference… even numbers x = 1 x = 2 y = x x = 4 x = x + 1 1 x 2 y 4 5

Garbage Collection Garbage collection: Automatically reclaim unused memory from heap Various strategies Reference counting Mark and Sweep

Reference Counting Store count of references to each heap allocation 0 references = garbage Once removed, things they point to may become 0 count

Reference Counting Problem: Cycles are not identified

Mark & Sweep Mark all heap allocations as dead Start from stack based variables Traverse pointers and mark hit allocations live Delete dead memory

Compaction Mark & Sweep may leave fragmented memory:

Compaction Mark & Sweep may leave fragmented memory: Allocations must be contiguous Allocation might fail even with enough space

Compaction Compaction : copy allocations so they are packed tightly:

Compaction Compaction : copy allocations so they are packed tightly: Expensive Need to “freeze” user code while addresses updated

Time Memory tends to be short lived or long lived:

Time Advanced GC uses different pools for: Young allocations – checked frequently Old allocatins – checked less frequently

Garbage Collection Pros Cons No need to worry about deleting memory System decides when to schedule cleanup work Less predictable lifespan for objects

Smart Pointers C++11 brought smart pointers Pointers do reference counting Memory released when last reference is released

Shared Ptr shared_ptr : counts number sharing the object When shared_ptr leaves scope, count-- Memory deleted when count == 0

Weak Ptr weak_ptr : keeps track of object without "counting" Can not be used directly Use to ask for a real shared ptr when needed Used to avoid cycles in shared_ptr

Unique Ptr unique_ptr : unshared pointer Can't copy can only move Deletes memory when pointer leaves scope

Courses With Strong/Weak Course Manager responsible for loading from DB

Courses With Strong/Weak Student asks for courses to be loaded Course manager creates objects, stores weak_ptr AND…

Courses With Strong/Weak Student asks for courses to be loaded Course manager creates objects, stores weak_ptr AND… Student given shared_ptrs refCount = 1 refCount = 1

Courses With Strong/Weak Student2 is keeping the Courses in memory courseManager knows where they are, can access if needed refCount = 1 refCount = 1

Courses With Strong/Weak New student asks for a new class Same process refCount = 1 refCount = 1 refCount = 1

Courses With Strong/Weak New student asks for an existing class CS162 courseManager checks its array, realizes it exists, gives Student1 a shared_ptr CS162 now has refcount of 2 refCount = 2 refCount = 1 refCount = 1

Courses With Strong/Weak Student2 destroyed… decrement refcount for CS271 and CS162 refCount = 1 refCount = 1 refCount = 0

Courses With Strong/Weak Student2 destroyed… decrement refcount for CS271 and CS162 shared_ptrs with refcount == 0 automatically deleted refCount = 1 refCount = 1

Courses With Strong/Weak courseManager has no way of knowing CS271 is deleted… Must check status of weak_ptr before using refCount = 1 refCount = 1

Objective C Can pick: Manual release Garbage collection (some platforms) ARC : Automatic Reference Counting Like shared_ptrs and weak_ptrs