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

What are some advanced 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 advanced examples:

1. Custom Deleters: You can provide a custom deleter to a unique_ptr to control how the memory is released. For example:

   auto customDeleter = [](int* p) { std::cout << "Deleting pointer" << std::endl; delete p; };
   std::unique_ptr<int, decltype(customDeleter)> ptr(new int(10), customDeleter);
   

2. Unique Pointer Arrays: You can use unique_ptr to manage arrays by using the array version of unique_ptr:

   std::unique_ptr<int[]> arr(new int[10]);
   

3. Factory Functions: You can create factory functions that return unique_ptrs to encapsulate object creation:

   std::unique_ptr<MyClass> createMyClass() {
       return std::make_unique<MyClass>();
   }
   

Would you like to see more examples or explanations on any specific use case?

Can you explain the custom deleter example in more detail?

Sure! A custom deleter allows you to define how a resource should be released when the unique_ptr goes out of scope. This is particularly useful when you need to perform additional actions during deletion, such as logging or releasing other resources.

In the example I provided:

auto customDeleter = [](int* p) { std::cout << "Deleting pointer" << std::endl; delete p; };
std::unique_ptr<int, decltype(customDeleter)> ptr(new int(10), customDeleter);

• We define a lambda function customDeleter that takes a pointer p and prints a message before deleting the pointer.
• We then create a unique_ptr named ptr, passing the new integer and the custom deleter. When ptr goes out of scope, it will call customDeleter, ensuring that our message is printed before the memory is freed.

This pattern is useful in scenarios where you want to manage resources more explicitly. Do you have any specific scenarios in mind where you might want to use a custom deleter?

Yes, I want to use it for managing file handles. Can you show me how?

Absolutely! Managing file handles with a custom deleter is a great use case for unique_ptr. Here's how you can do it:

#include <iostream>
#include <memory>
#include <cstdio> // for std::fclose

int main() {
    auto fileDeleter = [](FILE* f) {
        if (f) {
            std::cout << "Closing file handle" << std::endl;
            std::fclose(f);
        }
    };

    std::unique_ptr<FILE, decltype(fileDeleter)> filePtr(std::fopen("example.txt", "r"), fileDeleter);

    if (!filePtr) {
        std::cerr << "Failed to open file" << std::endl;
        return 1;
    }

    // Use the file handle...

    return 0; // filePtr will automatically close the file when it goes out of scope
}

In this example:

• We define a custom deleter fileDeleter that takes a FILE* and closes the file using std::fclose.
• We create a unique_ptr named filePtr, initializing it with a file opened by std::fopen and the custom deleter.
• When filePtr goes out of scope, it will automatically call fileDeleter, ensuring the file handle is closed properly.

This pattern helps prevent resource leaks and makes your code cleaner. Would you like to explore more about file handling or unique_ptr?