10 Smart Pointer Interview Questions and Answers – CLIMB

5. Explain how custom deleters work with unique_ptr and provide a code example.

Custom deleters in unique_ptr allow specifying a custom function to release resources when the unique_ptr goes out of scope.

#include 
#include 

struct FileDeleter {
    void operator()(FILE* file) const {
        if (file) {
            std::cout << "Closing file\n";
            fclose(file);
        }
    }
};

int main() {
    std::unique_ptr filePtr(fopen("example.txt", "w"));
    if (filePtr) {
        std::cout << "File opened successfully\n";
    }
    return 0;
}

6. Write a code snippet demonstrating exception safety with smart pointers.

#include 
#include 

void process_data(std::shared_ptr ptr) {
    if (!ptr) {
        throw std::runtime_error("Null pointer exception");
    }
    std::cout << "Processing data: " << *ptr << std::endl;
}

int main() {
    try {
        std::shared_ptr data = std::make_shared(42);
        process_data(data);
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }
    return 0;
}

7. Explain the purpose and usage of make_unique and make_shared.

make_unique and make_shared simplify the creation of std::unique_ptr and std::shared_ptr, respectively, ensuring resources are properly released.

#include 
#include 

int main() {
    std::unique_ptr uniquePtr = std::make_unique(42);
    std::cout << "Unique Pointer Value: " << *uniquePtr << std::endl;

    std::shared_ptr sharedPtr = std::make_shared(42);
    std::cout << "Shared Pointer Value: " << *sharedPtr << std::endl;

    return 0;
}

8. Discuss the ownership semantics of unique_ptr, shared_ptr, and weak_ptr.

Smart pointers manage the lifetime of dynamically allocated objects with different ownership semantics.

• unique_ptr: Exclusive ownership. The object is deleted when the unique_ptr goes out of scope. It can be moved to transfer ownership.

#include 
#include 

int main() {
    std::unique_ptr ptr1 = std::make_unique(10);
    std::unique_ptr ptr2 = std::move(ptr1); // Transfer ownership
    std::cout << *ptr2 << std::endl; // Output: 10
    return 0;
}

• shared_ptr: Shared ownership. The object is deleted when the last shared_ptr is destroyed. Uses reference counting.

#include 
#include 

int main() {
    std::shared_ptr ptr1 = std::make_shared(20);
    std::shared_ptr ptr2 = ptr1; // Shared ownership
    std::cout << *ptr1 << std::endl; // Output: 20
    std::cout << *ptr2 << std::endl; // Output: 20
    return 0;
}

• weak_ptr: Non-owning reference. Used to break circular references. Can be converted to shared_ptr if needed.

#include 
#include 

int main() {
    std::shared_ptr sharedPtr = std::make_shared(30);
    std::weak_ptr weakPtr = sharedPtr; // Weak reference
    if (auto tempPtr = weakPtr.lock()) { // Convert to shared_ptr
        std::cout << *tempPtr << std::endl; // Output: 30
    } else {
        std::cout << "Object no longer exists" << std::endl;
    }
    return 0;
}

9. Explain how to convert between different types of smart pointers.

To convert between smart pointers:

• Convert std::unique_ptr to std::shared_ptr using std::move.
• Convert std::shared_ptr to std::weak_ptr directly.
• Convert std::weak_ptr back to std::shared_ptr using the lock method.

Example:

#include 
#include 

int main() {
    std::unique_ptr uniquePtr = std::make_unique(10);
    std::shared_ptr sharedPtr = std::move(uniquePtr);

    std::weak_ptr weakPtr = sharedPtr;

    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Value: " << *lockedPtr << std::endl;
    } else {
        std::cout << "Pointer is expired." << std::endl;
    }

    return 0;
}

10. Given a scenario where multiple threads need to access a shared resource, how would you use smart pointers to manage this safely?

To manage shared resources safely in a multi-threaded environment, use smart pointers with synchronization primitives like std::mutex. Smart pointers manage the lifetime of objects, while a mutex ensures thread safety.

#include 
#include 
#include 
#include 
#include 

std::shared_ptr sharedResource;
std::mutex resourceMutex;

void accessResource(int id) {
    std::lock_guard lock(resourceMutex);
    if (sharedResource) {
        std::cout << "Thread " << id << " accessing resource: " << *sharedResource << std::endl;
    } else {
        std::cout << "Thread " << id << " found resource uninitialized." << std::endl;
    }
}

int main() {
    sharedResource = std::make_shared(42);

    std::vector threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(accessResource, i);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

In this example, std::shared_ptr manages the shared resource, and std::mutex ensures only one thread accesses the resource at a time. The std::lock_guard provides a convenient mechanism for acquiring and releasing the mutex.