Poligoni 777

#include <iostream>
#include <cmath>
using namespace std;

class Punto
{
    private:
        double _x;
        double _y;
    public:
        Punto();
        Punto(double x, double y);
        Punto(const Punto& p);
        ~Punto();
        Punto operator+(const Punto& p);
        Punto operator-(const Punto& p);
        Punto operator*(double x);
        Punto& operator=(const Punto& p);
        double distanza(const Punto& p);
        friend ostream& operator<<(ostream &os, const Punto& p);
        friend istream& operator>>(istream &is, Punto& p);
};

Punto::Punto()
{
    _x = 0.0;
    _y = 0.0;
}

Punto::Punto(double x, double y)
{
    _x = x;
    _y = y;
}

Punto::Punto(const Punto& p)
{
    _x = p._x;
    _y = p._y;
}

Punto::~Punto(){}

Punto Punto::operator+(const Punto& p)
{
    Punto q(_x + p._x, _y + p._y);
    return q;
}

Punto Punto::operator-(const Punto& p)
{
    Punto q(_x - p._x, _y - p._y);
    return q;
}

Punto Punto::operator*(double x)
{
    Punto q(_x * x, _y * x);
    return q;
}

Punto& Punto::operator=(const Punto& p)
{
    if (this != &p)
    {
        _x = p._x;
        _y = p._y;
    }
    return *this;
}

double Punto::distanza(const Punto& p)
{
    double dx = (_x - p._x);
    double dy = (_y - p._y);
    return sqrt(dx * dx + dy * dy);
}

ostream& operator <<(ostream& os, const Punto& p)
{
    os<<'('<<p._x<<','<<p._y<<')';
    return os;
}

istream& operator >>(istream& is, Punto&p)
{
    is>>p._x>>p._y;
}

class Poligono
{
    private:
        Punto* _array;
        int _vertici;
    public:
        Poligono();
        Poligono(int n);
        ~Poligono();
        Poligono operator*(double x);
        Poligono& operator=(const Poligono& p);
        Punto& operator[](int i);
        friend ostream& operator<<(ostream &os, const Poligono& p);
        friend istream& operator>>(istream &is, Poligono& p);
};

Poligono::Poligono()
{
    _array = NULL;
    _vertici = 0;
}

Poligono::Poligono(int n)
{

    _array = new Punto[n];
    _vertici = n;
}

Poligono::~Poligono()
{
    if (_array != NULL)
        delete[] _array;
}

Poligono Poligono::operator*(double x)
{
    Poligono q(_vertici);
    for (int i = 0; i < _vertici; i++)
        q._array[i] = _array[i] * x;
    return q;
}

Poligono& Poligono::operator=(const Poligono& p)
{
    if (this != &p)
    {
        if (_vertici != p._vertici)
        {
            delete[] _array;
            _array = new Punto[p._vertici];
            _vertici = p._vertici;
        }
        for (int i = 0; i < _vertici; i++)
            _array[i] = p._array[i];
    }
    return *this;
}

Punto& Poligono::operator[](int i)
{
    if (i>=0 && i<_vertici)
    {
        cout << i <<endl;
        return _array[i];
    }
}

ostream& operator<<(ostream &os, const Poligono& p)
{
    for (int i = 0; i < p._vertici; i++)
    {
        cout<<p._array[i]<<endl;
    }
}

istream& operator>>(istream &is, Poligono& p)
{
    for (int i = 0; i < p._vertici; i++)
    {
        cin>>p._array[i];
    }
}

int main()
{
    cout<<"Inserire numero vertici: ";
    int n;
    cin >> n;
    Poligono P(n);
    cin >> P;
    double perimetro = 0;
    for (int i = 1; i < n; i++)
    {
        perimetro += P[i].distanza(P[i-1]);
    }
    perimetro += P[0].distanza(P[n-1]);
    cout<<"Il perimetro è: "<<perimetro<<endl;
    cout << P;
    return 0;
}