How to create a dynamic array that can hold different objects all derived from the same base class in C++

Just wanted to elaborate on Nicky C's comment.

#include <memory>
using namespace std;

class Shape {};
class Rectangle : public Shape {};
class Circle : public Shape {};
template <class Type> class MyVector {}; // implement (with push method, etc.)

int main()
{
    MyVector<unique_ptr<Shape>> v;
    v.push(unique_ptr<Shape>(new Rectangle()));
    v.push(unique_ptr<Shape>(new Circle()));

    return 0;
}

The vector contains elements of type unique_ptr<Shape> which is the base class. Each element of the vector can be unique_ptr<Rectangle> or unique_ptr<Circle> as well. However, if the vector were of type unique_ptr<Rectangle>, each element would have to be of type unique_ptr<Rectangle> (i.e. it could not be of type unique_ptr<Circle>).

Since you are allocating memory on the heap, using unique_ptr just makes sure that you don't need to call delete yourself.

One of the strengths of inheritance/polymorphism is that you can use a derived class wherever a base class is needed. It is an important key concept. For instance, as in your code above, you can do:

Shape *s = new Shape();
s = new Rectangle();
s = new Circle();

This also applies to function parameters:

class DynamicArray
{
   private:
      Shape **_shapes[];
   ...
   public:
      void add_shape(Shape *s)
      {
         // Add the shape to _shapes;
      }
   ...
};

void main()
{
   DynamicArray array;
   array.add_shape(new Shape()):
   array.add_shape(new Rectangle()):
   array.add_shape(new Circle()):
}