Can you provide examples of using unique_ptr in C++?

Can you provide examples of using unique_ptr in C++?

Sure! A unique_ptr is a smart pointer that owns a dynamically allocated object exclusively. Here's a simple example:

#include <iostream>
#include <memory>

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

This code creates a unique_ptr that points to an integer initialized to 10.

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 cannot be copied. It can only be moved. Here's an example:

std::unique_ptr<int> ptr1 = std::make_unique<int>(20);
std::unique_ptr<int> ptr2 = ptr1; // This will cause a compilation error!

Instead, you should use std::move to transfer ownership.

Can you show me how to transfer ownership of a unique_ptr?

Absolutely! You can transfer ownership using std::move. Here's an example:

std::unique_ptr<int> ptr1 = std::make_unique<int>(30);
std::unique_ptr<int> ptr2 = std::move(ptr1);

if (!ptr1) {
    std::cout << "ptr1 is now null." << std::endl; // Outputs: ptr1 is now null.
}
std::cout << *ptr2 << std::endl; // Outputs: 30

In this code, ownership of the integer is transferred from ptr1 to ptr2.

Are there any performance benefits to using unique_ptr?

Yes, using unique_ptr can improve performance by eliminating the overhead of reference counting found in shared_ptr. It also helps prevent memory leaks by ensuring that the memory is automatically freed when the unique_ptr goes out of scope.