[POO] Test2_exp8

/*
Creati o clasa abstracta Figura care modeleaza o figura geometrica.
O figura geometrica este data printr-o secventa de 3 puncte in cazul unui triunghi, sau punct central si raza/latura in cazul cerc/patrat

* Derivati din clasa Figura, 3 tipuri de figuri geometrice:
  Triunghi, Patrat si Cerc.
* Creati un vector de figuri geometrice
* Calculati pentru fiecare figura geometrica perimetrul si aria
* Realizati o sortare a figurilor geometrice:
  - crescatoare in functie de perimetru
  - descrescatoare in functie de arie

Trebuie sa creati clasele Triunghi.cpp, Patrat.cpp, Cerc.cpp care sa fie derivate din clasa Figura si sa implementeze metodele.
Se acorda 2 pct pentru implementarea corecta a acestei ierarhii de clase (membri in clasa si constructor/destructor).

Fisierele nu contin si include-urile necesare (acestea trebuie sa le adaugati voi).
2 pct se dau daca programul compileaza.
Pentru sortarea figurilor se vor folosi functii din STL.

*/

// T2_exp8.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <vector>

using namespace std;

class Figure
{
public:
    //[3p] Perimetrul -> cate 1p implementarea din fiecare clasa
    virtual double  getPerimeter() = 0;

    //[3p] Aria -> cate 1p implementarea din fiecare clasa
    virtual double  getArea() = 0;

    //[3p] Numele -> cate 1p implementarea din fiecare clasa
    virtual string getName() = 0;
};

class Punct
{
private:
    //[1p] Coordonatele punctului.
    int X, Y;

public:
    //[1p] Constructorul implicit care plaseaza punctul în origine.
    Punct() {
        this->X = 0;
        this->Y = 0;
    }

    //[1p] Constructorul cu parametri.
    Punct(int x, int y) {
        this->X = x;
        this->Y = y;
    }

    //[1p] Resetarea coordonatelor la (0,0).
    void reset() {
        this->X = 0;
        this->Y = 0;
    }

    //[1p] Returneaza coordonata X a punctului.
    int getX() {
        return this->X;
    }

    //[1p] Returneaza coordonata Y a punctului.
    int getY() {
        return this->Y;
    }

    //[1p] Seteaza coordonata X a punctului.
    void setX(int x) {
        this->X = x;
    }

    //[1p] Seteaza coordonata Y a punctului.
    void setY(int y) {
        this->Y = y;
    }
};

class Cerc : public Figure
{
private :
    Punct P;
    int raza;
public:
    Cerc(Punct* PP, int raza) {
        this->P.setX(PP->getX());
        this->P.setY(PP->getY());
    }

    double getPerimeter() {
        return 2 * 3.14 * this->raza;
    }

    double getArea() {
        return 3.14 * (this->raza * this->raza);
    }
};

class Patrat : public Figure
{
private:
    Punct P;
    int latura;
public:
    Patrat(Punct* PP, int* lat) {
        this->P.setX(PP->getX());
        this->P.setY(PP->getY());
    }

    double getPerimeter() {
        return latura * 4;
    }

    double  getArea() {
        return (latura*latura) / 2;
    }
};

class Triunghi : public Figure
{

    Punct A, B, C;

public:
    Triunghi(Punct* PA, Punct* PB, Punct* PC) {
        this->A.setX( PA->getX() );
        this->A.setY( PA->getY() );

        this->B.setX( PB->getX() );
        this->B.setY( PB->getY() );

        this->C.setX( PC->getX() );
        this->C.setY( PC->getY() );
    }

    double  getPerimeter() {
        double lat[3];
        lat[0] = sqrt((this->B.getX() - this->A.getX()) * (this->B.getX() - this->A.getX()) + (this->B.getY() - this->A.getY()) * (this->B.getY() - this->A.getY()));
        lat[1] = sqrt((this->C.getX() - this->B.getX()) * (this->C.getX() - this->B.getX()) + (this->C.getY() - this->B.getY()) * (this->C.getY() - this->B.getY()));
        lat[2] = sqrt((this->A.getX() - this->C.getX()) * (this->A.getX() - this->C.getX()) + (this->A.getY() - this->C.getY()) * (this->A.getY() - this->C.getY()));

        return (lat[0] + lat[1] + lat[2]);
    }

    double  getArea() {
        double lat[3];
        lat[0] = sqrt((this->B.getX() - this->A.getX()) * (this->B.getX() - this->A.getX()) + (this->B.getY() - this->A.getY()) * (this->B.getY() - this->A.getY()));
        lat[1] = sqrt((this->C.getX() - this->B.getX()) * (this->C.getX() - this->B.getX()) + (this->C.getY() - this->B.getY()) * (this->C.getY() - this->B.getY()));
        lat[2] = sqrt((this->A.getX() - this->C.getX()) * (this->A.getX() - this->C.getX()) + (this->A.getY() - this->C.getY()) * (this->A.getY() - this->C.getY()));

        double p = getPerimeter() / 3;
        return sqrt( p * (p - lat[0]) * (p - lat[1]) * (p - lat[2]) );
    }
};

void main()
{
    Punct **points = (Punct**)malloc(4 * sizeof(Punct*));
    Figure **figs = (Figure**)malloc(5 * sizeof(Figure*));
    int puncte[4][2] = { { 10,2 },{ 12,0 },{ 14,13 },{ 6,13 } };
    int i;

    for (i = 0; i<4; i++)
        points[i] = new Punct(puncte[i][0], puncte[i][1]);

    figs[0] = (Figure*)new Cerc(points[0], 5);
    figs[1] = (Figure*)new Patrat(points[2], 4);
    figs[2] = (Figure*)new Patrat(points[3], 5);
    figs[3] = (Figure*)new Triunghi(points[0], points[1], points[3]);


    // Cream un vector de figuri geometrice

    vector <Figure*> vfig;
    for (i = 0; i<4; i++)
        vfig.push_back(figs[i]);

    //[3p] Sortam vectorul crescator in functie de perimetru

    //[3p] Sortam vectorul descrescator in functie de arie

}