For each of the following problems, write a program or a program segment that performs the specified action.Each problem refers to class Polygon (Fig. L 11.15). This class contains a dynamically allocated array of x-coordinates
and a dynamically allocated array of y-coordinates. These coordinates store the polygon’s vertices. The Polygon constructor takes the initial vertex for the Polygon.
1 // Coding Exercises: Polygon.cpp
2 // class Polygon definition
3 #include <iostream>
4 using std::ostream;
5 using std::endl;
6
7class Polygon
8 {
9 public:
10 Polygon( int = 0, int = 0 );
11 ~Polygon();
12
13 void addVertex( int, int );
14 int getNumVertices() const;
15 private:
16 int *xPts;
17 int *yPts;
18 int numVertices;
19 }; // end class Polygon
20
21 // default constructor
22 Polygon::Polygon( int x, int y )
23 {
24 xPts = new int[ 1 ];
25 yPts = new int[ 1 ];
26
27 xPts[ 0 ] = x;
28 yPts[ 0 ] = y;
29 numVertices = 1;
30 } // end class Polygon constructor
31
32 // destructor
33 Polygon::~Polygon()
34 {
35 delete [] xPts;
36 delete [] yPts;
37 } // end class Polygon destructor
38
39 // function addVertex definition
40 void Polygon::addVertex( int x, int y )
41 {
42 int *copyX = new int[ numVertices + 1 ];
43 int *copyY = new int[ numVertices + 1 ];
44
45 for ( int i = 0; i < numVertices; i++ )
46 {
47 copyX[ i ] = xPts[ i ];
48 copyY[ i ] = yPts[ i ];
49 } // end for
50
51 copyX[ numVertices ] = x;
52 copyY[ numVertices ] = y;
53
54 delete [] xPts;
55 delete [] yPts;
56
57 xPts = copyX;
58 yPts = copyY;
59 ++numVertices;
60 } // end function addVertex
61
62 // function getNumVertices
63 int Polygon::getNumVertices() const
64 {
65 return numVertices;
66 } // end function getNumVertices
1. Overload the stream-insertion operator << to output a Polygon object. The prototype for the << operator is
as follows:
ostream &operator<<( ostream &, const Polygon & );
2. Create a copy constructor for class Polygon. The prototype for the copy constructor is as follows:
Polygon( Polygon * );
3. Overload the == operator to compare two Polygons for equality. This member function should return a
boolean value. The prototype for the == operator is as follows:
bool operator==( Polygon & );
4. Overload the = operator to assign one Polygon object to another. This member function should return a const reference to the Polygon object invoking the member function. This member function also should test for self assignment. The prototype for the = operator is as follows:
const Polygon &operator=( const Polygon & );
5. Write a test program that does the follows:
a. Get user input to create a polygon called polygon1. You can do this by first asking the user for the number of vertices in the polygon and then asking for the (x,y) pairs for each vertex.
b. Output the polygon1 using your overloaded << operator function
c. Use the copy constructor to create another polygon called polygon2.
d. Output polygon2
e. Ask the user to input another polygon called polygon3.
f. Use your equality operator to compare polygon1 and polygon3. Output the result.
g. Create a new polygon called polygon4 using the default constructor
h. Assign polygon3 to polygon4 using your overloaded assignment operator function.
i. Output polygon4.
To solve the given problems, we need to provide program segments that perform the specified actions. Here is the solution for each problem:
Problem 1: Overload the stream-insertion operator << to output a Polygon object.
To overload the stream-insertion operator (<<), we need to define the function as a friend function of the Polygon class. Here's the code segment:
```cpp
ostream &operator<<(ostream &out, const Polygon &p) {
for (int i = 0; i < p.getNumVertices(); i++) {
out << "(" << p.xPts[i] << "," << p.yPts[i] << ") ";
}
return out;
}
```
Problem 2: Create a copy constructor for the Polygon class.
The copy constructor initializes a new Polygon object with the same values as the existing Polygon object. Here's the code segment:
```cpp
Polygon::Polygon(const Polygon &other) {
numVertices = other.numVertices;
xPts = new int[numVertices];
yPts = new int[numVertices];
for (int i = 0; i < numVertices; i++) {
xPts[i] = other.xPts[i];
yPts[i] = other.yPts[i];
}
}
```
Problem 3: Overload the == operator to compare two Polygon objects for equality.
To overload the == operator, we need to define it as a member function of the Polygon class. Here's the code segment:
```cpp
bool Polygon::operator==(const Polygon &other) {
if (numVertices != other.numVertices) {
return false;
}
for (int i = 0; i < numVertices; i++) {
if (xPts[i] != other.xPts[i] || yPts[i] != other.yPts[i]) {
return false;
}
}
return true;
}
```
Problem 4: Overload the = operator to assign one Polygon object to another.
To overload the = operator, we need to define it as a member function of the Polygon class. Here's the code segment:
```cpp
const Polygon &Polygon::operator=(const Polygon &other) {
if (this == &other) {
return *this;
}
delete[] xPts;
delete[] yPts;
numVertices = other.numVertices;
xPts = new int[numVertices];
yPts = new int[numVertices];
for (int i = 0; i < numVertices; i++) {
xPts[i] = other.xPts[i];
yPts[i] = other.yPts[i];
}
return *this;
}
```
Problem 5: Write a test program that performs the specified actions.
Here's a code segment that fulfills the requirements for the test program:
```cpp
int main() {
// a. Get user input to create polygon1
int numVertices;
cout << "Enter the number of vertices for polygon1: ";
cin >> numVertices;
Polygon polygon1;
for (int i = 0; i < numVertices; i++) {
int x, y;
cout << "Enter coordinates for vertex " << i + 1 << ": ";
cin >> x >> y;
polygon1.addVertex(x, y);
}
// b. Output polygon1 using the overloaded << operator
cout << "Polygon1: " << polygon1 << endl;
// c. Use the copy constructor to create polygon2
Polygon polygon2(polygon1);
// d. Output polygon2
cout << "Polygon2: " << polygon2 << endl;
// e. Ask the user to input polygon3
int numVertices3;
cout << "Enter the number of vertices for polygon3: ";
cin >> numVertices3;
Polygon polygon3;
for (int i = 0; i < numVertices3; i++) {
int x, y;
cout << "Enter coordinates for vertex " << i + 1 << ": ";
cin >> x >> y;
polygon3.addVertex(x, y);
}
// f. Use the equality operator to compare polygon1 and polygon3
cout << "Polygon1 == Polygon3: " << (polygon1 == polygon3) << endl;
// g. Create polygon4 using the default constructor
Polygon polygon4;
// h. Assign polygon3 to polygon4 using the overloaded = operator
polygon4 = polygon3;
// i. Output polygon4
cout << "Polygon4: " << polygon4 << endl;
return 0;
}
```
This test program allows the user to input polygons and performs the specified actions for each problem. The output is displayed accordingly.