Suppose I want to define a class named `Circle`, which has methods to calculate its area and perimeter. This class uses another class named `Point`. Suppose also that this class inherits from an abstract class named `Shape`.

So, I wrote the following code:

circle.h

```
#ifndef Circle_h
#define Circle_h
#include "Point.h"
#include "Shape.h"

class Circle : public Shape
{
public:

    Circle(const Point &ceneter , int radius);
    ~Circle();

    virtual double getArea() const ;
    virtual double getPerim() const ;

private:
    int radius;
    Point center;
};

#endif 

```

shape.h

```
#ifndef Shape_h
#define Shape_h
#include "Point.h"
#include <iostream>

class Shape          //abstract class//
{
public:

    virtual double getArea() const=0;
    virtual double getPerim() const=0;
};

#endif 

```

point.h

```
#ifndef Point_h
#define Point_h

class Point
{
public:

    Point(int x, int y);
    ~Point();

    int getX() const;
    int getY() const;

    void setX(int x);
    void setY(int y);

private:

    int x, y;
};

#endif 

```

I am not so sure about 2 things:

1. **Should I add a c'tor and d'ctor to the `Shape` class?** 

Cause as far as I understand it, since that class is abstract, there is no need in them.
2. **Should I add `override` to the overridden methods in `Circle`, like this?**

```
virtual double getArea() const override ;
virtual double getPerim() const override ;

```
3. Suppose I write the following (in the main):

```
Point o(0, 0);

Point a(0, 1);

Point b(1, 0);

Shape *shapes[] = { new Circle(a, 2), new Circle(b,3), new Circle(o, 1 };

```

**How does the last line whould influence on the need to use (or not use) c'tor and d'tor?**