figure.h

#pragma once
#include<iostream>
#include<cmath>
#include<string>
using namespace std;

class Shape {
public:
    virtual int shape_perimetr()=0;
    virtual int shape_area() = 0;
    virtual ~Shape() {};

};

class Polygon : public Shape {
public:
    virtual string get_shape() const {
        return "Polygon";
    }
};

class Square : public Polygon {
protected:
    int diagonal;
public:
    Square() :diagonal(0) {}
    Square(int d) : diagonal(d) {}
    Square(const Square& s) : diagonal(s.diagonal) {}

    int get_diagonal() const {
        return diagonal;
    }
    string get_shape() const {
        return "Square:" + to_string(diagonal) + "cm";
    }
    int shape_perimetr()  {
        return 4 * diagonal;
    }
    int shape_area() {
        return pow(diagonal, 2);
    }

    friend ostream& operator<<(ostream& out, const Square& s) {
        out << s.diagonal << "cm" << endl;
        return out;
    }
    /*friend iostream& operator>>(istream& in, Square& s) {
        in >> s.diagonal;
        return in;
    }*/
};

class Rectungle :public Polygon {
protected:
    int side1;
    int side2;
public:
    Rectungle() :side1(0), side2(0) {}
    Rectungle(int s1, int s2) : side1(s1),side2(s2) {}
    Rectungle(const Rectungle& r) : side1(r.side1),side2(r.side2) {}

    string get_shape() const {
        return "Rectangle:" + to_string(side1) + "cm," + to_string(side2) + "cm";
    }
    int shape_perimetr() {
        return 2 * (side1 + side2);
    }
    int shape_area() {
        return side1 * side2;
    }
    friend ostream& operator<<(ostream& out, const Rectungle& r) {
        out << r.side1 << "cm &" << r.side2<<"cm"<< endl;
        return out;
    }
    /*friend iostream& operator>>(istream& in, Rectungle& r) {
        in >> r.side1;
        in >> r.side2;
        return in;
    }*/
};

class Triangle : public Polygon {
protected:
    int a;
    int b;
    int c;
public:
    Triangle() : a(0), b(0), c(0) {}
    Triangle(int t_height) :a(t_height), b(t_height), c(t_height) {}
    Triangle(int aa,int bb,int cc): a(aa), b(bb),c(cc){}
    Triangle(const Triangle&t): a(t.a), b(t.b), c(t.c){}

    string get_shape() const {
        return "Triangle:" + to_string(a) + "cm," + to_string(b) + "cm," + to_string(c) + "cm";
    }
    int shape_perimetr() {
        return a + b + c;
    }
    int shape_area() {
        return sqrt(Triangle::shape_perimetr() * (Triangle::shape_perimetr() - a) * (Triangle::shape_perimetr() - b) * (Triangle::shape_perimetr() - c));
    }

    friend ostream& operator<<(ostream& out, const Triangle& t) {
        out << t.a << "cm &" << t.b << "cm &" << t.c << "cm" << endl;
        return out;
    }
    /*friend iostream& operator>>(istream& in, Triangle& t) {
        in >> t.a;
        in >> t.b;
        in >> t.c;
        return in;
    }*/
};

class Circle :public Shape {
protected:
    int radius;
public:
    Circle() :radius(0) {}
    Circle(int r) :radius(r) {}
    Circle(const Circle& c) :radius(c.radius) {}

    string get_shape() const {
        return "Circle: radius is " + to_string(radius) + "cm";
    }
    int get_radius() const {
        return radius;
    }
    int shape_perimetr() {
        return 2 * 3,14 * radius;
    }
    int shape_area() {
        return 3,14 * pow(radius, 2);
    }

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