#include <iostream>
#include <iomanip>
#include <string>

#include <cstring>
#include <cmath>

using namespace std;

const char* g_pt_sep = ", ";

class Point
{
public:
    Point() : m_x(0.0), m_y(0.0) {}
    Point(const double x, const double y) : m_x(x), m_y(y) {}
    Point(const Point& pt)
    {
	m_x = pt.m_x;
	m_y = pt.m_y;
    }
    Point& operator=(const Point& pt)
    {
	if(this != &pt)
	{
	    m_x = pt.m_x;
	    m_y = pt.m_y;
	}
	return *this;
    }
    bool operator!=(const Point& pt) const
    {
	bool inequality = false;
	if(m_x != pt.m_x || m_y != pt.m_y)
	{
	    inequality = true;
	}
	return inequality;
    }
    bool operator==(const Point& pt) const
    {
	bool equality = false;
	if(m_x == pt.m_x && m_y == pt.m_y)
	{
	    equality = true;
	}
	return equality;
    }
    friend ostream& operator<<(std::ostream& os, const Point& pt)
    {
	os << fixed << pt.m_x << g_pt_sep << pt.m_y;
	return os;
    }
    friend istream& operator>>(std::istream& is, Point& pt)
    {
	is >> fixed >> pt.m_x;
	is.ignore(strlen(g_pt_sep));
	is >> fixed >> pt.m_y;
	return is;
    }
    double distance(const Point& pt) const
    {
	// makes unsafe assumptions about x, y values
	double result = 0.0;
	if(this != &pt)
	{
	    result = sqrt(pow(pt.m_x - m_x, 2) + pow(pt.m_y - m_y, 2));
	}
	return result;
    }
protected:
    std::string m_sep;
private:
    double m_x;
    double m_y;
};

class Shape2D
{
public:
    virtual Point& getPoint() const = 0;
    virtual void setPoint(const Point& pt) = 0;
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual ~Shape2D() {}
protected:
private:
    double m_size;
    Point* m_ppt; // center
};

class Rectangle : public Shape2D
{
public:
    Rectangle() : m_ppt(0) {}
    Rectangle(const Rectangle& rectangle) : Shape2D()
    {
	m_size = rectangle.m_size;
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
	m_ppt = new Point(*rectangle.m_ppt);
    }	
    ~Rectangle()
    {
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
    }
    Point& getPoint() const
    {
	return *m_ppt;
    }
    void setPoint(const Point& pt)
    {
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
	m_ppt = new Point(pt);
    }
    double getSize() const
    {
	return m_size;
    }
    void setSize(const double size)
    {
	m_size = size; // is size height, length?
    }
    double area() const
    {
	double result = 0.0;
	return result; // not enough information to calculate
    } 
    double perimeter() const
    {
	double result = 0.0;
	return result; // not enough information to calculate
    } 
protected:
private:
    double m_size;
    Point* m_ppt; // center
};

class Circle : public Shape2D
{
public:
    Circle() : m_ppt(0) {}
    Circle(const Circle& circle) : Shape2D()
    {
	m_size = circle.m_size;
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
	m_ppt = new Point(*circle.m_ppt);
    }	
    ~Circle()
    {
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
    }
    Point& getPoint() const
    {
	return *m_ppt;
    }
    void setPoint(const Point& pt)
    {
	if(m_ppt != NULL)
	{
	    delete m_ppt;
	}
	m_ppt = new Point(pt);
    }
    double getSize() const
    {
	return m_size;
    }
    void setSize(const double size)
    {
	m_size = size; // is size radius, diameter?
    }
    double area() const
    {
	double result = 0.0;
	return result; // not enough information to calculate
    } 
    double perimeter() const
    {
	double result = 0.0;
	return result; // not enough information to calculate
    } 
protected:
private:
    double m_size;
    Point* m_ppt; // center
};

int main()
{
    Point p1(1, 2);
    Point p2;
    cout << "Enter a value for p2: ";
    cin >> p2;
    cout << "Distance between p1 (" << p1 << ") and p2 (" << p2 << ") = " << p1.distance(p2) << endl;

    Rectangle r;
    r.setSize(42);
    cout << "r.getSize() = " << r.getSize() << endl;

    Circle c;
    c.setSize(42);
    cout << "c.getSize() = " << c.getSize() << endl;


    return 0;
}