Understanding unique_ptr in C++

  • By
  • Posted in C++
  • Updated
  • 5 mins read

Memory management is one of the most important aspects of programming in C++. Improper management of memory can lead to severe issues like memory leaks, dangling pointers, and crashes. Prior to C++11, manual memory management was done using new and delete, but this approach was error-prone and hard to manage in larger applications.

C++11 introduced smart pointers to address these problems. One of the most significant additions in this context was std::unique_ptr, which simplifies memory management by automating resource cleanup, making code more robust, concise, and safer. This article will dive into std::unique_ptr, explaining how it works, why it’s useful, and providing details on various use cases.

unique_ptr

std::unique_ptr is a smart pointer that manages a dynamically allocated object and ensures that the object is automatically destroyed when the std::unique_ptr is destroyed (i.e., when it goes out of scope or is reset). The key feature of std::unique_ptr is that it has exclusive ownership over the object it manages. No other pointer can take ownership of the same object simultaneously unless ownership is explicitly transferred (using move semantics).

  • Exclusive Ownership: A unique_ptr exclusively owns the object it points to.
  • Automatic Memory Management: It automatically deletes the object it owns when it goes out of scope.
  • Non-Copyable: Copying a unique_ptr is not allowed, but it can be moved to transfer ownership.
  • Custom Deleters: You can specify custom deletion logic.

Basic Usage of std::unique_ptr

Creating a std::unique_ptr

To create a std::unique_ptr, the preferred approach is to use the factory function std::make_unique (introduced in C++14). This function avoids potential memory leaks by ensuring that memory is allocated and assigned to the std::unique_ptr in one step.

#include <iostream>
#include <memory>


class DatabaseConnection {
public:
    
    DatabaseConnection(const std::string& dbName) : dbName_(dbName) {
        std::cout << "Connecting to database: " << dbName_ << std::endl;
        connected_ = true;
    }

    
    ~DatabaseConnection() {
        if (connected_) {
            std::cout << "Disconnecting from database: " << dbName_ << std::endl;
            connected_ = false;
        }
    }

    
    void executeQuery(const std::string& query) {
        if (connected_) {
            std::cout << "Executing query: " << query << std::endl;
        } else {
            std::cout << "Cannot execute query. Not connected to database." << std::endl;
        }
    }

private:
    std::string dbName_;
    bool connected_; 

};

int main() {
    
    // Create a unique_ptr to manage the DatabaseConnection object
    std::unique_ptr<DatabaseConnection> dbConnection = std::make_unique<DatabaseConnection>("MyDatabase");

    // Perform operations using the connection
    dbConnection->executeQuery("SELECT * FROM users");
    return 0;
}/// At this point, dbConnection goes out of scope, the unique_ptr is destroyed,
// and the DatabaseConnection object is automatically deleted, closing the connection.

In the above code, a std::unique_ptr named dbConnection owns an object of DatabaseConnection. When the scope of dbConnection ends (i.e., when main() returns), dbConnection automatically deletes destroyed.

Creating std::unique_ptr Manually (Without make_unique)

Although std::make_unique is the recommended way, you can still manually create a std::unique_ptr using new. This method, however, can be prone to exceptions and is discouraged unless you have a specific reason to avoid std::make_unique.

 std::unique_ptr<DatabaseConnection> dbConnection(new DatabaseConnection("MyDatabase"));

The primary advantage of using std::make_unique is that it provides exception safety. If an exception is thrown between the new call and the assignment to ptr, a memory leak can occur. std::make_unique avoids this problem by combining allocation and assignment in one step.

Memory Ownership and Management

std::unique_ptr follows the RAII (Resource Acquisition Is Initialization) principle. RAII ensures that resources are tied to the lifetime of objects. When an object is destroyed, its associated resources are automatically released. This is particularly useful in exception-prone code, as the cleanup is handled automatically.

int main() {
    
    // Create a unique_ptr to manage the DatabaseConnection object
    std::unique_ptr<DatabaseConnection> dbConnection = std::make_unique<DatabaseConnection>("MyDatabase");

    // Perform operations using the connection
    dbConnection->executeQuery("SELECT * FROM users");
    return 0;
}

In this example, object of DatabaseConnection as soon as dbConnection goes out of scope (i.e., when main() exits).

Move Semantics and Transfer of Ownership

One of the defining features of std::unique_ptr is move semantics, which allows ownership of the resource to be transferred from one std::unique_ptr to another. Since std::unique_ptr ensures exclusive ownership, it cannot be copied. Attempting to copy a std::unique_ptr results in a compilation error

std::unique_ptr<DatabaseConnection> otherDbConnection = std::move(dbConnection);

Managing Arrays with std::unique_ptr

std::unique_ptr can also be used to manage dynamically allocated arrays. Instead of using delete, the array version of std::unique_ptr will use delete[] to free the memory.

To manage arrays, you can use std::make_unique as follows

std::unique_ptr<int[]> arr = std::make_unique<int[]>(5); // Create a unique_ptr to an array of 5 integers

arr[0] = 10;
std::cout << arr[0] << std::endl;

When the std::unique_ptr goes out of scope, the delete[] operator is called, automatically freeing the array’s memory.

Resetting a std::unique_ptr

If you want to replace the object managed by std::unique_ptr, you can use the reset() function. This deallocates the currently managed object and optionally assigns a new object to the std::unique_ptr.

ptr.reset(); // Deletes the currently owned object, making ptr null
ptr.reset(new int(100)); // Resets ptr to manage a new integer
Tags: ,