What are some examples of using shared pointers in C++?

What are some examples of using shared pointers in C++?

Shared pointers in C++ are smart pointers that manage the lifetime of an object through reference counting. Here are a few examples:

1. Basic Usage:

   #include <iostream>
   #include <memory>
   
   int main() {
       std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
       std::cout << *ptr1 << std::endl; // Outputs: 10
       return 0;
   }
   

2. Sharing Ownership:

   #include <iostream>
   #include <memory>
   
   void display(std::shared_ptr<int> ptr) {
       std::cout << *ptr << std::endl;
   }
   
   int main() {
       std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
       display(ptr1); // Outputs: 20
       return 0;
   }
   

3. Circular References:

   #include <iostream>
   #include <memory>
   
   struct Node {
       std::shared_ptr<Node> next;
   };
   
   int main() {
       std::shared_ptr<Node> node1 = std::make_shared<Node>();
       std::shared_ptr<Node> node2 = std::make_shared<Node>();
       node1->next = node2;
       node2->next = node1; // This creates a circular reference
       return 0;
   }
   

These examples illustrate how shared pointers can be used to manage memory automatically.

What happens in the case of circular references?

In the case of circular references with shared pointers, the reference count will never reach zero, leading to a memory leak. This happens because each shared pointer keeps a reference to the other, preventing their destruction. To avoid this, you can use std::weak_ptr for one of the pointers in the circular reference, which does not contribute to the reference count.

Can you show an example of using weak pointers?

Certainly! Here's an example of using std::weak_ptr to break a circular reference:

#include <iostream>
#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // Use weak_ptr to avoid circular reference
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->prev = node1; // This does not increase the reference count
    return 0;
}

In this example, node2 holds a weak pointer to node1, preventing a circular reference and allowing both nodes to be destroyed when they go out of scope.