The type Point is a fairly simple data type that represents a point in the

two-dimensional plane. Write a definition of a class named Point that might be used

to store and manipulate the location of a point in the plane. You will need to declare

and implement the following member functions:

(a) a member function set that sets the private data after an object of this class is

created.

(b) a member function to move the point by an amount along the vertical and

horizontal directions specified by the first and second arguments.

(c) two const functions to retrieve the current coordinates of the point.

Embed your class in a test program that requests data for several points from the user,

creates the points, then exercises the member functions.

Document these functions with appropriate comments. embed your class in a test program that request data for several points from the user ,creates the points , then exercises the member functions.

so for I had this

```
#include <iostream>
#include <cmath>
using namespace std;
class Point
{
public:
Point(double initial_x = 0, double initial_y = 0);
void shift(double x_amount, double y_amount);
void rotate90();
int rotation_needed(Point p);
void rotation_upper_right(Point &p);
double get_x() const {return x;}
double get_y() const {return y;}
friend istream& operator >>(istream &ins, Point &target);
private:
double x;
double y;
};
//NON-MEMBER FUNCTIONS
double distance(const Point &p1, const Point &p2);
Point mid_point(const Point &p1, const Point &p2);
bool operator ==(const Point &p1, const Point &p2);
bool operator !=(const Point &p1, const Point &p2);
Point operator +(const Point &p1, const Point &p2);
ostream& operator <<(ostream &outs, const Point &source);
Point::Point(double initial_x, double initial_y)
{
x = initial_x;
y = initial_y;
}
void Point::shift(double x_amount, double y_amount)
{
x += x_amount;
y += y_amount;
}
void Point::rotate90()
{
double new_x;
double new_y;
new_x = y;
new_y = -x;
x = new_x;
y = new_y;
}
int Point::rotation_needed(Point p)
{
int answer = 0;
while((p.get_x() < 0) || (p.get_y() < 0))
{
p.rotate90();
answer++;
}
return answer;
}
void Point::rotation_upper_right(Point &p)
{
while((p.get_x() < 0) || (p.get_y() < 0))
{
p.rotate90();
}
}
double distance(const Point &p1,const Point &p2)
{
double a, b, c_square;
a = p1.get_x() - p2.get_x();
b = p1.get_y() - p2.get_y();
c_square = a*a + b*b;
return (sqrt(c_square));
}
Point mid_point(const Point& p1, const Point& p2)
{
double x_midpoint, y_midpoint;
x_midpoint = (p1.get_x() + p2.get_x()) / 2;
y_midpoint = (p1.get_y() + p2.get_y()) / 2;
Point midpoint(x_midpoint, y_midpoint);
//construct new object midpoint with values of x_midpoint and y_midpoint
return midpoint;
}
bool operator ==(const Point &p1, const Point &p2)
{
return ((p1.get_x() == p2.get_x()) && (p1.get_y() == p2.get_y()));
}
bool operator !=(const Point &p1, const Point &p2)
{
return (!(p1 == p2));
}
Point operator +(const Point &p1, const Point &p2)
{
double x_sum, y_sum;
x_sum = p1.get_x() + p2.get_x();
y_sum = p1.get_y() + p2.get_y();
Point sum(x_sum, y_sum);
return sum;
}
ostream& operator <<(ostream &outs, const Point &source)
{
outs << source.get_x() << " " << source.get_y();
return outs;
}
istream& operator >>(istream &ins, Point &target)
{
ins >> target.x >> target.y;
return ins;
}
```

I have some linking problems