Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Passing Around Unique Pointers | Unique Pointers
C++ Smart Pointers
course content

Course Content

C++ Smart Pointers

C++ Smart Pointers

1. Introduction to Smart Pointers
Understanding Pointers and Heap MemoryThe Need For Smart PointersSmart Pointer Use CasesReferences Use CasesBenefits of Using Smart Pointers and References
2. Unique Pointers
What Are Unique Pointers?Creating Unique PointersApplication For Unique PointersPassing Around Unique PointersInner Workings of a Unique PointerUnique Pointers and Templates
3. Shared Pointers
What Are Shared Pointers?Creating and Sharing Shared PointersShared Pointer Functions to RememberShared Pointers vs Unique PointersBest Practices of Using Shared PointersShared Pointers Practice
4. Weak Pointers
Understanding Weak PointersCreating And Using Weak PointersBreaking Circular References With Weak PointersImportant Weak Pointer Functions
5. References
How Are References Different From Pointers?Constant References And ImmutabilityWhen to Use References vs Smart Pointers vs Raw PointersReferences Best Practices
6. Advanced topics
Providing Custom Deleters For Smart PointersReal-World Applications of Smart PointersPerformance Considerations With Smart PointersDefinitive Guide to Shared vs Unique vs Weak Pointers

bookPassing Around Unique Pointers

When is it okay to pass unique pointers?

One of the primary reasons we choose pointers and dynamic memory allocation over static variables is the flexibility they offer in passing data throughout different sections of code. However, when it comes to unique pointers, the passing around gets a bit tricky.

Note

There are certain best practices that you should follow when accessing unique pointers beyond the scope in which they were initialized.

When returning from builder functions:

One valid use case for passing a unique pointer is when you are returning from a builder function (a function which exists only to allocate/build resources).

cpp

uniquePtrBuilder

copy

              
123456789101112131415161718

            
#include <iostream>
#include <memory>

std::unique_ptr<int> uniquePtrBuilder() {
    return std::make_unique<int>(42);   
    // builder function initializes a new unique pointer 
    // and instantly returns it, transferring ownership to caller
}

int main() {
    // this will be the sole owner of the dynamically allocated integer 42
    std::unique_ptr<int> myUniquePtr = uniquePtrBuilder();

    if (myUniquePtr)
        std::cout << "Value from unique pointer: " << *myUniquePtr << std::endl;
    else
        std::cout << "Unique pointer is null." << std::endl;
}

In the above code, we are using a builder function to create a unique pointer to an integer value. Once the function returns, the myUniquePtr in the main function starts pointing to the dynamic integer value.

When transferring ownership

It’s also considered valid and safe to move a unique pointer. For example, you may transfer the ownership of a unique pointer from class A to class B.

When is it not okay to pass unique pointers?

Sharing a std::unique_ptr with the intention of multiple parties owning it is not suitable. This breaks the core concept of a unique pointer, as it should have only one owner.

For example, you may create a unique pointer instance inside a class and then pass its raw pointer to an external library function. Such sharing is unsafe and can lead to hard-to-debug memory problems.

When is it considered appropriate to pass a unique pointer?

When is it considered appropriate to pass a unique pointer?

Select the correct answer

Everything was clear?

How can we improve it?

Thanks for your feedback!

Section 2. Chapter 4
some-alt