C++ Creating an array then populating it with elements of a class - c++

Question

In my class we are creating a dynamic array and learning how to use free store and de-allocating data correctly. We are creating a Line container that holds a Point class which contains points on a graph, this assignment is building off of another assignment of ours but uses new Line member functions.
I am currently having issues with actually creating the array and populating it with coordinates of points. I am not really sure how to begin writing the Main(), what my idea is so far is to create the Line array that will contain members of my Point class. I want to initialize 5 elements and then add 6 so it will create a new array with more elements.
So far I have the following thought on how to start it.
Line* points = new Line[5];
for ( int i = 0; i < 5; i++ ){
points[i] = 0; //This causes "no match for ‘operator=’ (operand types are ‘Line’ and ‘int’)"
}
Then I would probably try to assign points with members of my point class
Point pointOne(1.0, 1.0)
I've tried adding elements like the following but its incorrect.
points[0] -> (1.0, 1.0);
points[0] = pointOne;
Here are my .h and .cpp files
Line.cpp
#include "Point.h"
#include "Line.h"
#include <stdexcept>
//default constructor
Line::Line(){
size();
index = 0;
points = new Point[size()];
Point::Point();
}
//destructor
Line::~Line(){
delete[] points;
}
void Line::push_back(const Point& p){
if(index == size()) // If array is too small copy all data to a new array, reassign pointer
{
Point * temp = new Point[size() + 5]; //temp array in free store
for(size_t i = 0; i < size(); i++)
{
temp[i] = points[i];
}
delete[] points; //clear array
points = temp; //reassign values
points[index++] = p; //Places p into array
delete[] temp;
points[size()] = (5 + size());
}
else
{
points[index++] = p;
}
}
/**
* Clear the list of points by setting index to 0.
*/
void Line::clear(){
delete[] points;
}
/**
* Return the length of the line. The length is calculated as
* the sum of the distance between all points in the line.
*/
double Line::length(){
double total = 0.0;
for (unsigned int index = 0; (index+1) < 10; index++){ //Loop for index and index+1 to prevent going out of the vector
total += points[index].distance(points[index+1]); //Add up distance (A to B) + (B to C) etc
}
return total;
}
/**
* return the number of Points contained in our line
*/
unsigned int Line::size() const{
int i = 5;
return i;
}
/**
* [] operator override
*/
Point & Line::operator[](int index){ //rewrite out-of-bounds
if(index == size())
{
throw std::out_of_range("Out of bounds.");
}
return points[index];
}
Line.h
#ifndef LINE_H_
#define LINE_H_
#include "Point.h"
class Line {
public:
/**
* Constructor and destructor
*/
Line();
virtual ~Line();
/**
* Add a point to the end of our line. If the line contains
*/
void push_back(const Point& p);
/**
* Clear the list of points
*/
void clear();
/**
* Return the length of the line. The length is calculated as
* the sum of the distance between all points in the line.
*/
double length();
/**
* return the number of Points in our line
*/
unsigned int size() const;
/**
* [] operator override
*/
Point & operator[](int index);
private:
unsigned int index; //index of array
Point *points; //Pointer to data
};
#endif /* LINE_H_ */
Point.cpp
#include "Point.h"
#include "Line.h"
#include <cmath>
#include <stdexcept>
/** default constructor **/
Point::Point(){
// TODO Auto-generated constructor stub
this->x = 0.0;
this->y = 0.0;
}
//Overloaded Constructor
Point::Point(const double x, const double y){
// TODO Auto-generated constructor stub
this->x = x;
this->y = y;
}
/**
* Copy constructor */
Point::Point(const Point & t){
x = t.x;
y = t.y;
}
//Default destructor
Point::~Point() {
// TODO Auto-generated destructor stub
}
//Retrieve X value
double Point::getX() const {
return x;
}
//Retrieve Y value
double Point::getY() const {
return y;
}
//Function for finding distance between 2 points on a graph. Using ((x-p.x)^2+(y-p.y)^2)^1/2
double Point::distance(const Point &p) const{
return sqrt( pow((x - p.getX()),2) + pow((y - p.getY()),2));
}
/**
* Output the Point as (x, y) to an output stream
*/
std::ostream& operator <<(std::ostream &out , const Point &point){
out <<'(' << point.x << ',' << ' ' << point.y << ')';
return out;
}
/**
* Declare math operators
*/
//Addition
Point operator +(const Point &lhs, const Point &rhs){
return Point(lhs.x + rhs.x, lhs.y + rhs.y);
}
//Subtraction
Point operator -(const Point &lhs, const Point &rhs){
return Point(lhs.x - rhs.x, lhs.y - rhs.y);
}
/**
* Copy assignment
*/
Point & Point::operator =(const Point& rhs){
x= rhs.x;
y= rhs.y;
return *this;
}
Point.h
#ifndef POINT_H_
#define POINT_H_
#include <iostream>
class Point {
public:
/**
* Constructor and destructor
*/
Point();
Point(const double x, const double y);
virtual ~Point();
/**
* Get the x value
*/
double getX() const;
/**
* Get the y value
*/
double getY() const;
/**
* Return the distance between Points
*/
double distance(const Point &p) const;
/**
* Output the Point as (x, y) to an output stream
*/
friend std::ostream& operator <<(std::ostream &out, const Point &point);
/**
* Declare comparison relationships
*/
friend bool operator ==(const Point &lhs, const Point &rhs);
friend bool operator <(const Point &lhs, const Point &rhs);
/**
* Declare math operators
*/
friend Point operator +(const Point &lhs, const Point &rhs);
friend Point operator -(const Point &lhs, const Point &rhs);
/**
* Copy constructor
*/
Point(const Point& t);
/**
* Copy assignment
*/
Point &operator =( const Point& rhs );
private:
double x;
double y;
};
#endif /* POINT_H_ */