How to declare std::unique_ptr and what is the use of it?

std::unique_ptr is a smart pointer introduced in C++11 for managing dynamically allocated memory. It ensures that only one pointer points to a specific memory resource at a time, meaning that when the std::unique_ptr is destroyed or goes out of scope, the object it points to is automatically destroyed (via delete). This feature is highly effective in preventing memory leaks and ensuring exception safety.

How to Declare std::unique_ptr

To declare a std::unique_ptr, include the header <memory>. The basic syntax is as follows:

cpp
#include <memory>

std::unique_ptr<Type> pointerName;

For example, to declare a std::unique_ptr pointing to an int, you can write:

cpp
std::unique_ptr<int> myIntPtr;

To initialize the smart pointer with a specific object, use std::make_unique (recommended since C++14):

cpp
auto myIntPtr = std::make_unique<int>(10);

Here, myIntPtr points to a dynamically allocated int initialized to 10.

Purpose of std::unique_ptr

1. Resource Management: The primary purpose of std::unique_ptr is to manage dynamically allocated memory, ensuring that resources are automatically released when no longer needed, thus preventing memory leaks.

2. Explicit Transfer of Resource Ownership: Since std::unique_ptr cannot be copied (only moved), it is ideal for scenarios requiring explicit ownership transfer. For example, when passing large data structures between functions, using std::unique_ptr avoids unnecessary data copying while maintaining clear ownership.

3. Working with Containers and Other Standard Library Components: Although std::unique_ptr cannot be copied, it can be moved. This means it can be stored in standard containers supporting move semantics, such as std::vector.

Practical Example

Suppose you are developing an application where a function creates a large data structure and passes it to another function for processing:

cpp
std::unique_ptr<LargeDataStructure> createLargeData() {
    return std::make_unique<LargeDataStructure>();
}

void processLargeData(std::unique_ptr<LargeDataStructure> data) {
    // Process data
}

int main() {
    auto data = createLargeData();
    processLargeData(std::move(data));
    return 0;
}

In this example, the createLargeData function creates and returns a std::unique_ptr<LargeDataStructure>, which is then passed to processLargeData. By using std::unique_ptr and move semantics, we avoid data copying while ensuring clear ownership transfer between functions.