/*IMP


Yes, exactly! If you need to pass the pointer between multiple functions without losing ownership or control of the resource,
you should use std::shared_ptr instead of std::unique_ptr. Here's why:

Key Differences:
std::unique_ptr: Ownership is exclusive. If you pass it to another function, ownership is transferred (using std::move), and the 
original function no longer holds a valid pointer.

std::shared_ptr: Ownership is shared among multiple parts of your code. The pointer is reference-counted, meaning that the resource
it points to will only be destroyed when the last shared_ptr pointing to it goes out of scope.

When to Use std::shared_ptr:

You should use std::shared_ptr when:
You need to share ownership of a resource between multiple functions or objects.
You don't want the resource to be destroyed until every reference to it is gone.
*/


#include <iostream>
#include <memory>

class MyClass {
    public:
        int x;
        void print() {
            std::cout << "x = " << x << std::endl;
        }
};

int main() {
    // Create a shared pointer to an object of type MyClass
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    ptr1->x = 5;
    ptr1->print();
    std::cout << "Number of shared pointers: " << ptr1.use_count() << std::endl;

    // Create another shared pointer that points to the same object
    std::shared_ptr<MyClass> ptr2 = ptr1;
    std::cout << "Number of shared pointers: " << ptr1.use_count() << std::endl;

    // Modify the object using the second shared pointer
    ptr2->x = 6;
    ptr2->print();
    std::cout << "Number of shared pointers: " << ptr2.use_count() << std::endl;

    // Reset the first shared pointer
    ptr1.reset();
    std::cout << "Number of shared pointers: " << ptr2.use_count() << std::endl;

    // The object will be deleted when the last shared pointer goes out of scope
    return 0;
}

/* 

uses of shared pointer
There are several use cases for shared pointers in C++:

Memory management: Shared pointers automatically manage the memory of the object
they point to, by keeping track of the number of references to the object. When
the last shared pointer pointing to the object goes out of scope, the object is
deleted, and the memory is freed. This helps prevent memory leaks and other 
memory-related errors.

Shared ownership: Shared pointers provide a way to share ownership of an object
among multiple pointers. This can be useful in situations where multiple parts 
of the code need to access the same object.

Concurrent programming: Shared pointers can be used to implement thread-safe data 
structures, such as shared pointers to atomic variables, which can be used to 
synchronize access to shared data.

cyclic references: Shared pointers can be used to break cyclic references,
which can be a problem when using raw pointers.

Creating objects on heap: Shared pointer can be used to create an object on heap,
which can be useful when creating an object in a function.

It's worth noting that shared pointers use reference counting to keep track of the
number of pointers pointing to the object, this can add some overhead in terms of
performance, but it's a trade-off for the benefits shared pointers provide.

-------------------------------------------------------------------------

sharing pointer in c++ with ex

A shared pointer in C++ is a type of smart pointer that keeps track of the number
of references to the object it points to. The object will be automatically deleted
when the last shared pointer pointing to it is destroyed or goes out of scope.

Here is an example of how to use a shared pointer in C++:

Copy code
std::shared_ptr<int> ptr1 = std::make_shared<int>(5);
std::shared_ptr<int> ptr2 = ptr1;
std::cout << "Value of the int object: " << *ptr1 << std::endl;
std::cout << "Number of shared pointers: " << ptr1.use_count() << std::endl;

In this example, ptr1 is a shared pointer that owns an int object with the value of 5.
ptr2 is also a shared pointer that points to the same object as ptr1. The use_count()
method returns the number of shared pointers that point to the object, which in 
this case is 2.

We use shared pointers because they automatically manage the memory they point to,
which helps prevent memory leaks and other memory-related errors. They also provide
a way to share ownership of an object among multiple pointers, which can be useful 
in certain situations where multiple parts of the code need to access the same
object.

Additionally, unlike a unique pointer, multiple shared pointers can point to 
the same object, making it easier to share ownership among multiple parts of the 
code.

It's worth noting that shared pointers use reference counting to keep track of 
the number of pointers pointing to the object, this can add some overhead in terms
of performance, but it's a trade-off for the benefits shared pointers provide.

It's recommended to use shared pointers instead of raw pointers, if you are not 
sure about the ownership, but you want to share the ownership among multiple 
pointers.
*/