What are some examples of using shared_ptr in C++?

Can you give me some examples of using shared_ptr in C++?

Sure! A shared_ptr is a smart pointer that retains shared ownership of an object through a pointer. Here's a simple example:

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr2 shares ownership with ptr1
        std::cout << "Use count: " << ptr1.use_count() << std::endl;
    } // ptr2 goes out of scope here
    std::cout << "Use count after ptr2 goes out of scope: " << ptr1.use_count() << std::endl;
    return 0;
}

This code demonstrates creating a shared_ptr and how the use count changes.

What happens when the last shared_ptr goes out of scope?

When the last shared_ptr that owns the object goes out of scope, the reference count drops to zero, and the managed object is automatically deleted. This helps prevent memory leaks.

Can you explain the difference between shared_ptr and unique_ptr?

Certainly! A unique_ptr is a smart pointer that owns an object exclusively, meaning no other unique_ptr can point to the same object. In contrast, shared_ptr allows multiple pointers to share ownership of the same object, managing the reference count to ensure proper deletion.

Are there any performance considerations when using shared_ptr?

Yes, using shared_ptr can introduce some overhead due to reference counting and atomic operations. If you don't need shared ownership, prefer using unique_ptr for better performance.