Please just fix the errors and make it match with the expected output.

The point of this program

Create and test a class called Points2. This class describes a sequence of 2D points. For example (1, 3), (4, 5) is a sequence of two points, where each coordinate is an integer. (1.2, 3.4), (5.6, 10.1), (11.1, 12.0) is a sequence of three points where each coordinate is a double. A sequence can have any size. An empty sequence has size 0

Below I have also included the expected output.

But for some reason, the output that my code produces is not the same as the expected code I have provided.

The copy assignment does not seem to work, the move assignment and the operator overloading + are only a few points that do not work.

Especially plz make the overloading operating + work and produce the expected output. Otherwise, my code fully works.

Please let me know what the mistakes of my code are! Thank you

#ifndef CSCI335_HOMEWORK1_POINTS2_H_

#define CSCI335_HOMEWORK1_POINTS2_H_

#include

#include

#include

#include

#include

namespace teaching_project {

// Place comments that provide a brief explanation of the class,

// and its sample usage.

template

class Points2 {

public:

// Default "big five" -- you have to alter them for your assignment.

// That means that you will remove the "= default" statement.

// and you will provide an implementation.

// Zero-parameter constructor.

// Set size to 0.

Points2():size_{0}, sequence_{nullptr} {

}

// Copy-constructor.

Points2(const Points2 &rhs){

size_ = rhs.size_; //copies over the size

//this->sequence_ = new std::array[size_](); //allocates space for new sequence

sequence_= new std::array{*rhs.sequence_};

for (size_t i=0; i

this->sequence_[i] = rhs.sequence_[i];

}

// sequence_= new std::array{*rhs.sequence_};

}

// Copy-assignment. If you have already written

// the copy-constructor and the move-constructor

// you can just use:

// {

// Points2 copy = rhs;

// std::swap(*this, copy);

// return *this;

// }

/* Points2& operator=(const Points2 &rhs) {

{

Points2 copy = rhs;

std::swap(*this, copy);

return *this;

} */

Points2& operator=(const Points2 &rhs) {

if (this != &rhs){

*sequence_ = *rhs.sequence_;

}

return *this;

}

// Move-constructor.

Points2(Points2 &&rhs){

sequence_=rhs.sequence_;

size_=rhs.size_;

*this = std::move(rhs);

rhs.sequence_= nullptr;

rhs.size_=0;

}

// Move-assignment.

// Just use std::swap() for all variables.

Points2& operator=(Points2 &&rhs) {

/* *this = std::move(rhs);

return *this;*/

std::swap(this->sequence_, rhs.sequence_);

std::swap(this->size_, rhs.size_);

return *this;

}

~Points2() {

delete []sequence_;

}

// End of big-five.

// One parameter constructor.

Points2(const std::array& item): size_{1} {

// Provide code.

sequence_ = new std::array[1];

sequence_[0][0] = item[0];

sequence_[0][1] = item[1];

//std::copy(item.begin(), item.end(), sequence_);

}

// Read a chain from standard input.

void ReadPoints2() {

// Part of code included (without error checking).

std::string input_line;

std::getline(std::cin, input_line);

std::stringstream input_stream(input_line);

if (input_line.empty()) return;

// Read size of sequence (an integer).

int size_of_sequence;

input_stream >> size_of_sequence;

// std::cout << "Size: " << size_of_sequence;

// Allocate space for sequence.

// Add code here.

sequence_ = new std::array[size_of_sequence]; //allocates space for new sequence

size_ = size_of_sequence;

// Object token;

for (int i = 0 ; i < size_of_sequence; ++i) {

// for (int i = 0 ;input_stream >> token; ++i) {

Object x, y;

input_stream >> x >> y;

//std::cout << "Reading " << x << ", " << y << std::endl;

//array arr{x, y};

//std::cout<<"(";

sequence_[i][0] = x; //.fill(x);

sequence_[i][1] = y; // fill(y);

//std::cout<<")";

// }

}

/*for (int i = 0; i < size_; ++i){

std::cout << "("<< sequence_[i][0] << " " << sequence_[i][1] << ")" << std::endl;

}*/

}

size_t size() const {

return size_;

}

// @location: an index to a location in the sequence.

// @returns the point at @location.

// const version.

// abort() if out-of-range.

const std::array& operator[](size_t location) const {

if( location > size_ ) {

abort();

}

return sequence_[location];

}

// Code missing.

// @c1: A sequence.

// @c2: A second sequence.

// @return their sum. If the sequences are not of the same size, append the

// result with the remaining part of the larger sequence.

/* friend Points2 operator+(const Points2 &c1, const Points2 &c2) {

Points2