The University of Iowa
The College of Liberal Arts and Sciences
Department of Computer Science

Programming Languages and Tools:

CS:3210:0001

Lecture/Lab #20

Programming with C++

Smart pointers (cont.): unique_ptr, shared_ptr

Warm up

What will be the output of the following program?

void bar( int* ptr ) {
    *(ptr + 2) = 33;
    *(ptr + 4) = 55;
}

int main() {
    int a[10] = { 0, 0, 0, 0, 0, 
                  0, 0, 0, 0, 0 };
    bar( a );
    for ( auto n : a )
        std::cout << n << " ";
    std::cout << std::endl;

    int* b = new int[5]();
    bar( b );
    for ( auto n : b )
        std::cout << n << " ";
    std::cout << std::endl;

    int* c = new int( 42 );
    bar( c );
    std::cout << *c << std::endl;
 }

std::unique_ptr

https://repl.it/@agurtovoy/lab20-unique-ptr

widget* w = new widget();

// ...

delete w;

auto w = std::make_unique<widget>();

// ...

“Owns” the object to which it points

The object is destroyed when unique_ptr is destroyed

u.release() relinquishes the ownership and sets u value to nullptr

Only one unique_ptr at a time can point to a given object.

make_unique<T>(...) function allocates the object of type T on the heap and returns a unique_ptr that owns it

u.reset( raw_ptr ) resets existing unique_ptr's value

Cannot be copied, but can be moved using std::move

Exercise 1

Fix compilation/run-time problems according to the expressed intent of the code and following modern C++ guidelines

https://repl.it/@agurtovoy/lab20-exercise1

Open the exercise template

Write your code, press Run to test

When you're done, grab your Repl's link and send it as a direct message to me (agurtovoy)

Click on the corresponding option in the "Lab20 exercises" poll in #general

shared_ptr

No specific shared_ptr owns the object.

Shared object ownership

All shared_ptrs pointing to a specific object "collaborate" to ensure the object is destructed when it’s no longer needed.

When the last shared_ptr pointing to an object stops pointing there, that shared_ptr destroys the object it points to.

https://repl.it/@agurtovoy/lab20-shared-ptr

widget* w = new widget();
foo( w );

widget* w2 = w;
// ...
if ( no_one_uses )
   delete w;

auto w = std::make_shared<widget>();
foo( w );

auto w2 = w;
// ...

shared_ptr (cont.)

T* ptr

[control block]*

T object

reference count

weak count

other data (custom deleter, etc.)

Control block

Twice the size of a raw pointer

Reference counter is dynamically allocated

Primary characteristics:

Reference counter increments/decrements are atomic

Supports custom deleters

shared_ptr<T>