How the array of std::shared_ptr in C++ works - c++

Question

I am a c++ beginner and learning about smart pointers and inheritance. I have a base class Shape(abstract) and as derived classes I have Triangle, Isosceles and Equilateral.
My idea is to print appropriate print message for each class according to the type which is pointed the base class, which I have declared in the main() as shown below.
#include <iostream>
#include <memory>
class Shape
{
public:
virtual const void triangle()const = 0;
virtual ~Shape(){ std::cout<<"Shape Deleted\n"; }
};
class Triangle: public Shape
{
public:
virtual const void triangle()const override
{ std::cout<<"I am a triangle\n"; }
virtual ~Triangle(){ std::cout<<"Triangle Deleted\n"; }
};
class Isosceles : public Triangle
{
public:
virtual const void triangle()const override
{ std::cout<<"I am an isosceles triangle\n"; }
virtual ~Isosceles(){ std::cout<<"Isosceles Deleted\n"; }
};
class Equilateral: public Isosceles
{
public:
virtual const void triangle()const override
{ std::cout<<"I am an equilateral triangle\n"; }
virtual ~Equilateral(){ std::cout<<"Equilateral Deleted\n"; }
};
When I use traditional way of creating a pointer object using new key word, the distructors of all classes works perfectly(out put is given below).
The main() was:
int main()
{
Shape *Obj[3];
Obj[0] = new Equilateral();
Obj[1] = new Isosceles();
Obj[2] = new Triangle();
for(auto it: Obj)
it->triangle();
delete Obj[0];
return 0;
}
The output is here
But when I change to std::shared_ptr things are different which I could not understand.
The main() was:
int main()
{
std::shared_ptr<Shape> obj[3];
obj[0] = std::make_shared<Equilateral>();
obj[1] = std::make_shared<Isosceles>();
obj[2] = std::make_shared<Triangle>();
for(auto it: obj)
it->triangle();
return 0;
}
The Output Now:
Can anybody help me figure it out, why this happens?
may thanks in advance.

Answer 1

When you use raw pointers you only destroy the first object:
delete Obj[0];
and make other 2 leak, while when you use std::shared_ptr all 3 objects cleaned properly. This is exact reason why using smart pointers is recommended practice.

Answer 2

Actually your second snippet is correct and the output is exactly as expected.
Your first snippet has a bug: you just delete obj[0];. What about obj[1] and obj[2]? If you delete all members of the array, you'll see that the difference between the outputs of two code samples vanish.
The good thing about smart pointers is that they are supposed to be used in a "fire-and-forget" manor.
Finally, read that book of yours with greater caution: you need to master the order of construction and destruction before starting anything about OOP.