Uniqueness of objects in shared pointers

Let’s consider code below:

``````class A {
string a;
public A(string a) : a(a) { }
};

class B : public A {
public B(string a) : A(a) { }
};

int main() {
std::shared_ptr<A> x1 = std::make_shared<B>("x");
std::shared_ptr<A> x2 = std::make_shared<B>("x");

A* atom1 = x1.get();
A* atom2 = x2.get();

A* atom1X = std::make_shared<B>("x").get();
A* atom2X = std::make_shared<B>("x").get();

bool condition1 = (atom1 == atom2);
bool condition2 = (atom1X == atom2X);

}
``````

The result is surprising me because condition1 is false but condition2 is true.
Why? Can you explain what is going on here?

I was researching on the internet. I want to understand how it works

>Solution :

``````A* atom1X = std::make_shared<B>("x").get(); // (1)
A* atom2X = std::make_shared<B>("x").get(); // (2)
``````

In these definitions, `std::make_share<B>("x")` creates a temporary `std::shared_ptr` that ceases to exist at the end of the full expression (essentially at the next `;`). That means that the object each of these pointers points to gets destroyed immediately after being created.

By the time `atom2X` is declared the object pointed to by `atom1X` has been destroyed and its storage deallocated. It just so happens that the storage previously occupied by the object allocated in line (1) is exactly the right size to hold a `B` object, so it gets re-used in line (2).

Essentially, if you remove all of the smart pointers, you can think of your code as being equivalent to this:

``````A* x1 = new B("x");
A* x2 = new B("x");

A* atom1 = x1;
A* atom2 = x2;

A* atom1X = new B("x");
delete atom1X;
A* atom2X = new B("x");
delete atom2X;
``````