What are some unique use cases for std::unique_ptr in C++?

What are some unique use cases for std::unique_ptr in C++?

std::unique_ptr is a smart pointer in C++ that manages the lifetime of dynamically allocated objects. Here are some unique use cases:

1. Resource Management: Automatically deallocate resources when they go out of scope.
2. Custom Deleters: Use unique_ptr with custom deleters for specialized cleanup.
3. Factory Functions: Return unique_ptr from factory functions to ensure ownership semantics.
4. Arrays: Manage dynamic arrays with unique_ptr using std::unique_ptr<T[]>.
5. Polymorphism: Store derived class objects in a unique_ptr to base class.

Can you explain how to use unique_ptr with custom deleters?

Certainly! You can use unique_ptr with custom deleters by providing a deleter function or lambda when you create the unique_ptr. For example:

#include <iostream>
#include <memory>

void customDeleter(int* p) {
    std::cout << "Deleting pointer: " << p << std::endl;
    delete p;
}

int main() {
    std::unique_ptr<int, decltype(&customDeleter)> ptr(new int(10), customDeleter);
    return 0;
}

In this example, when the unique_ptr goes out of scope, it will call the customDeleter function.

What happens if I try to copy a unique_ptr?

If you try to copy a unique_ptr, it will result in a compilation error because unique_ptr is designed to be non-copyable. This ensures that there is a single owner of the resource. However, you can move a unique_ptr using std::move, which transfers ownership.

Are there any performance benefits to using unique_ptr?

Yes, using unique_ptr can lead to performance benefits. It eliminates the overhead of reference counting found in shared_ptr, making it more efficient for single ownership scenarios. Additionally, it helps prevent memory leaks and dangling pointers, leading to safer and more maintainable code.