What are some examples of using unique_ptr in C++?

What are some examples of using unique_ptr in C++?

Unique pointers are a smart pointer type in C++ that manage the lifetime of dynamically allocated objects. Here are a few examples:

1. Basic Usage:

   #include <memory>
   
   int main() {
       std::unique_ptr<int> ptr = std::make_unique<int>(10);
       std::cout << *ptr << std::endl; // Outputs: 10
       return 0;
   }
   

2. Transferring Ownership:

   void transferOwnership(std::unique_ptr<int> p) {
       std::cout << *p << std::endl;
   }
   
   int main() {
       std::unique_ptr<int> ptr = std::make_unique<int>(20);
       transferOwnership(std::move(ptr)); // ptr is now nullptr
   }
   

3. Array of Unique Pointers:

   std::unique_ptr<int[]> arr = std::make_unique<int[]>(5);
   for (int i = 0; i < 5; ++i) {
       arr[i] = i;
   }
   

   These examples illustrate how to create, transfer, and manage arrays with unique_ptr.

Can you explain the benefits of using unique_ptr over raw pointers?

Certainly! The benefits of using unique_ptr over raw pointers include:

1. Automatic Memory Management: unique_ptr automatically deallocates the memory when it goes out of scope, reducing the risk of memory leaks.
2. Ownership Semantics: It clearly defines ownership of the resource, ensuring that only one unique_ptr can own a resource at a time, preventing double deletions.
3. Exception Safety: In the event of an exception, unique_ptr ensures that the memory is properly released, which is not guaranteed with raw pointers.
4. No Overhead: Unlike other smart pointers, unique_ptr has no overhead for reference counting, making it lightweight and efficient.

What are some common mistakes to avoid when using unique_ptr?

Some common mistakes to avoid when using unique_ptr include:

1. Not Using std::move: When transferring ownership, always use std::move to avoid compiler errors or unintended behavior.
2. Using unique_ptr with Arrays Incorrectly: When creating an array of objects, use std::unique_ptr<Type[]> and std::make_unique<Type[]>(size) to ensure proper deletion.
3. Mixing Raw Pointers and unique_ptr: Avoid using raw pointers to manage the same resource as a unique_ptr, as this can lead to double deletions or memory leaks.
4. Not Resetting unique_ptr: If you need to reuse a unique_ptr, remember to call reset() to release the current resource before assigning a new one.