Figures.h

#pragma once


#define PI 3.14159265358979323846

using namespace std;

class Shape {
public:

    virtual double ShapePerimeter() = 0;
    virtual double ShapeSquare() = 0;

    virtual ~Shape() {};

};

//-------------------------------------------//

class Polygon:public Shape{};

//-------------------------------------------//

class Square :public Polygon {
    double diagonal;
public:
    Square() :diagonal(0) {}
    Square(double s_diagonal) :diagonal(s_diagonal) {}
    Square(const Square& s) :diagonal(s.diagonal) {}

    double GetDiagonal() const {
        return diagonal;
    }


    double ShapePerimeter() {
        return 4 * diagonal;
    }

    double ShapeSquare() {
        return pow(diagonal,2);
    }

    friend ostream &operator<<(ostream& out, const Square& s) {
        out << s.diagonal << "cm" << endl;
        return out;
    }

    friend istream &operator>>(istream& in, Square& s) {
        in >> s.diagonal;
        return in;
    }
};

//-------------------------------------------//

class Rectangle :public Polygon {
    double side1;
    double side2;

public:
    Rectangle() :side1(0),side2(0) {}
    Rectangle( double r_diagonal):side1(r_diagonal),side2(r_diagonal){}
    Rectangle(double r_side1 , double r_side2) :side1(r_side1),side2(r_side2) {}
    Rectangle(const Rectangle& r) :side1(r.side1), side2(r.side2) {}

    double ShapePerimeter() {
        return 2*(side1+side2);
    }

    double ShapeSquare()  {
        return side1*side2;
    }

    friend ostream& operator<<(ostream& out, const Rectangle& r) {
        out << r.side1<<"cm" << " x " << r.side2 << "cm" << endl;
        return out;
    }

    friend istream& operator>>(istream& in, Rectangle& r) {
        in >> r.side1;
        in >> r.side2;
        return in;
    }
};

//-------------------------------------------//

class Triangle : public Polygon {
    double side1;
    double side2;
    double side3;

public:
    Triangle():side1(0),side2(0),side3(0){}
    Triangle(double t_height):side1(t_height),side2(t_height),side3(t_height){}
    Triangle(double t_side1 ,double t_side2, double t_side3):side1(t_side1),side2(t_side2),side3(t_side3){}
    Triangle(const Triangle &t):side1(t.side1), side2(t.side2),side3(t.side3){}

    double ShapePerimeter(){
        return side1 + side2 + side3;
    }

    double ShapeSquare() {
        return sqrt(Triangle::ShapePerimeter() * (Triangle::ShapePerimeter() - side1) * (Triangle::ShapePerimeter() - side2)
                 * (Triangle::ShapePerimeter() - side3));
    }

    friend ostream& operator<<(ostream& out, const Triangle& t) {
        out << t.side1 << "cm" << " x " << t.side2 << "cm" <<" x "<<t.side3<<"cm"<<endl;
        return out;
    }

    friend istream& operator>>(istream& in, Triangle& t) {
        in >> t.side1;
        in >> t.side2;
        in >> t.side3;
        return in;
    }
};

//-------------------------------------------//

class Circle : public Shape {
    double radius;

public:
    Circle():radius(0){}
    Circle(double c_radius):radius(c_radius){}
    Circle(const Circle& c):radius(c.radius){}

    double ShapePerimeter()override {
        return 2 * PI * radius;
    }
    double ShapeSquare()override {
        return PI*pow(radius, 2);
    }

    friend ostream& operator<<(ostream& out, const Circle& c) {
        out <<"radius-"<<c.radius<< "cm" << endl;
        return out;
    }
    friend istream& operator>>(istream& in, Circle& c) {
        in >> c.radius;
        return in;
    }

};