C++ Interview Questions

Smart pointers in C++ are objects that manage the lifetime of dynamically allocated memory and ensure that the memory is properly deallocated when it is no longer needed. They are part of the C++ Standard Library and are designed to prevent memory leaks and dangling pointers by automatically handling the deallocation of memory. Smart pointers provide the same functionality as regular pointers, but with additional safety and convenience features.

There are three main types of smart pointers in C++: std::unique_ptr, std::shared_ptr, and std::weak_ptr. Each has its own use cases and advantages.

1. std::unique_ptr:

   • Description: std::unique_ptr is a smart pointer that owns and manages a dynamically allocated object through a pointer and disposes of that object when the std::unique_ptr goes out of scope. It ensures unique ownership, meaning that there is only one std::unique_ptr that owns a particular object at any time.
   • Use Case: Use std::unique_ptr when you need sole ownership of a resource, and the resource should be automatically deallocated when the pointer goes out of scope.
   • Example:

     #include <memory>
     #include <iostream>
     
     class MyClass {
     public:
         MyClass() { std::cout << "MyClass Constructor\n"; }
         ~MyClass() { std::cout << "MyClass Destructor\n"; }
     };
     
     int main() {
         std::unique_ptr<MyClass> ptr1(new MyClass());
         // std::unique_ptr<MyClass> ptr2 = ptr1; // Error: can't copy unique_ptr
         std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // Transfer ownership
         return 0;
     }

2. std::shared_ptr:

   • Description: std::shared_ptr is a smart pointer that maintains shared ownership of an object through a reference count. Multiple std::shared_ptr instances can share ownership of the same object, and the object is destroyed when the last std::shared_ptr owning it is destroyed or reset.
   • Use Case: Use std::shared_ptr when multiple parts of your program need to share ownership of a resource, and the resource should be deallocated only when the last owner releases it.
   • Example:

     #include <memory>
     #include <iostream>
     
     class MyClass {
     public:
         MyClass() { std::cout << "MyClass Constructor\n"; }
         ~MyClass() { std::cout << "MyClass Destructor\n"; }
     };
     
     int main() {
         std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
         {
             std::shared_ptr<MyClass> ptr2 = ptr1; // Shared ownership
             std::cout << "ptr2 goes out of scope\n";
         }
         // Object is not destroyed yet because ptr1 still owns it
         std::cout << "ptr1 goes out of scope\n";
         return 0;
     }

3. std::weak_ptr:

   • Description: std::weak_ptr is a smart pointer that holds a non-owning ("weak") reference to an object managed by std::shared_ptr. It is used to break circular references that can occur with std::shared_ptr. A std::weak_ptr does not affect the reference count of the std::shared_ptr and must be converted to std::shared_ptr before the object can be accessed.
   • Use Case: Use std::weak_ptr to reference an object that is managed by std::shared_ptr without participating in the reference counting system, which helps prevent cyclic dependencies that can cause memory leaks.
   • Example:

     #include <memory>
     #include <iostream>
     
     class MyClass {
     public:
         MyClass() { std::cout << "MyClass Constructor\n"; }
         ~MyClass() { std::cout << "MyClass Destructor\n"; }
         std::shared_ptr<MyClass> ptr;
     };
     
     int main() {
         std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
         std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
         ptr1->ptr = ptr2; // Circular reference
         ptr2->ptr = ptr1; // Circular reference
     
         std::weak_ptr<MyClass> weakPtr = ptr1; // Weak reference to break circular dependency
     
         if (auto sharedPtr = weakPtr.lock()) { // Convert weak_ptr to shared_ptr
             std::cout << "Object is still alive\n";
         } else {
             std::cout << "Object has been destroyed\n";
         }
     
         return 0;
     }

Summary:
Smart pointers in C++ provide automatic and safe memory management by ensuring that dynamically allocated memory is properly deallocated when it is no longer needed. std::unique_ptr offers unique ownership semantics, std::shared_ptr provides shared ownership with reference counting, and std::weak_ptr helps manage non-owning references to avoid circular dependencies. Using smart pointers instead of raw pointers can significantly reduce memory leaks and make C++ programs more robust and maintainable.