C++ ONLY!!! Create 4 classes that inherit the polygon pure virtual base class yo
ID: 3713728 • Letter: C
Question
C++ ONLY!!!
Create 4 classes that inherit the polygon pure virtual base class you adjusted and defined in Exercise 1. Those polygons are assumed to be perfect (no irregular shapes). The polygons are as follows: This will be the parent class for all two dimensional polygons you will be working with in this assignment.
polygon.h
#ifndef POLYGON_H
#define POLYGON_H
class polygon{
private:
int sides;
public:
polygon(int sides); //Constructor - default sides to 3
polygon(const polygon*); //Copy constructor
void setSides(int sides); //setter for private attribute
int getSides() const; //Getter for private attribute
//Other functions
virtual double calcArea()=0; //calculates the area of a polygon
virtual double calcPerimeter()=0; //calculates the perimeter of a polygon
virtual void printDimensions()=0; //displays the dimensions of a polygon along with its area and perimeter
};
#endif
polygon.cpp
#include
#include "polygon.h"
using namespace std;
polygon::polygon(int sides) //Constructor - default sides to 3
{
this->sides = sides;
}
polygon::polygon(const polygon *p)//Copy constructor
{
this->sides = p->sides;
}
void polygon::setSides(int sides) //setter for private attribute
{
this->sides = sides;
}
int polygon::getSides() const //Getter for private attribute
{
return sides;
}
- triangle (triangle.h and triangle.cpp)
- rectangle (rectangle.h and rectangle.cpp)
- pentagon (pentagon.h and pentagon.cpp)
- hexagon (hexagon.h and hexagon.cpp)
Research how to calculate the area and perimeter for each of these shapes and be sure to override the appropriate base class functions to achieve this. In the printDimensions() function, be sure to output what each polygon (rectangle, triangle, etc) is along with its pertinent dimensions and the number of sides.
In the rectangle class, add a boolean member function, isSquare() that is true when the sides of the rectangle object are equal. If the object is a square output that information as a part of the output of the rectangle object.
Explanation / Answer
triangle.h
#ifndef TRIANGLE_H
#define TRIANGLE_H
#include "polygon.h"
class triangle : public polygon{
private:
double dimensions[3];
public:
triangle(double);
triangle(const triangle*);
double calcArea();
double calcPerimeter();
void setDimention(double side_a, double side_b, double side_c);
void printDimensions();
};
#endif
triangle.cpp
#include <cmath>
#include <iostream>
#include "triangle.h"
//#include "polygon.cpp"
using namespace std;
triangle::triangle(double side_a, double side_b, double side_c) : polygon(3)
{
dimensions[0] = side_a;
dimensions[1] = side_b;
dimensions[2] = side_c;
}
triangle::triangle(const triangle* other) : polygon(other)
{
dimensions[0] = other -> dimensions[0];
dimensions[1] = other -> dimensions[1];
dimensions[2] = other -> dimensions[2];
}
double triangle::calcArea()
{
double p = calcPerimeter()/2;
double area = sqrt(p * (p - dimensions[0]) * (p - dimensions[1]) * (p - dimensions[2]));
return area;
}
double triangle::calcPerimeter()
{
return dimensions[0]+ dimensions[1] + dimensions[2];
}
void triangle::setDimention(double side_a, double side_b, double side_c)
{
dimensions[0] = side_a;
dimensions[1] = side_b;
dimensions[2] = side_c;
}
void triangle::printDimensions()
{
cout << "Side 1: " << dimensions[0] << endl;
cout << "Side 2: " << dimensions[1] << endl;
cout << "Side 3: " << dimensions[2] << endl;
}
------------------------------------------------------------------------------------------
rectangle.h
#ifndef RECTANGLE_H
#define RECTANGLE_H
#include "polygon.h"
class rectangle : public polygon{
private:
double dimensions[2];
public:
rectangle(double);
rectangle(const rectangle*);
double calcArea();
double calcPerimeter();
void setDimention(double length, double breadth);
void printDimensions();
};
#endif
rectangle.cpp
#include <iostream>
#include "rectangle.h"
//#include "polygon.cpp"
using namespace std;
rectangle::rectangle(double length, double breadth) : polygon(4)
{
dimensions[0] = length;
dimensions[1] = breadth;
}
rectangle::rectangle(const rectangle* other) : polygon(other)
{
dimensions[0] = other -> dimensions[0];
dimensions[1] = other -> dimensions[1];
}
double rectangle::calcArea()
{
double area = dimensions[0] * dimensions[1];
return area;
}
double rectangle::calcPerimeter()
{
return 2 * (dimensions[0]+ dimensions[1]);
}
void rectangle::setDimention(double length, double breadth)
{
dimensions[0] = length;
dimensions[1] = breadth;
}
void rectangle::printDimensions()
{
cout << "length: " << dimensions[0] << endl;
cout << "breadth: " << dimensions[1] << endl;
}
------------------------------------------------------------------------------------------
pentagon.h
#ifndef PENTAGON_H
#define PENTAGON_H
#include "polygon.h"
class pentagon : public polygon{
private:
double dimensions;
public:
pentagon(double);
pentagon(const pentagon*);
double calcArea();
double calcPerimeter();
void setDimention(double side);
void printDimensions();
};
#endif
pentagon.cpp
#include <cmath>
#include <iostream>
#include "pentagon.h"
//#include "polygon.cpp"
using namespace std;
pentagon::pentagon(double side) : polygon(5)
{
dimensions = side
}
pentagon::pentagon(const pentagon* other) : polygon(other)
{
dimensions = other -> dimensions;
}
double pentagon::calcArea()
{
double area = dimensions * dimensions * 5 / (4 * tan ( 3.14159265 / 5 ));
return area;
}
double pentagon::calcPerimeter()
{
return 5 * dimensions;
}
void pentagon::setDimention(double side)
{
dimensions = side;
}
void pentagon::printDimensions()
{
cout << "sides: " << dimensions << endl;
}
------------------------------------------------------------------------------------------
hexagon.h
#ifndef HEXAGON_H
#define HEXAGON_H
#include "polygon.h"
class hexagon : public polygon{
private:
double dimensions;
public:
hexagon(double);
hexagon(const hexagon*);
double calcArea();
double calcPerimeter();
void setDimention(double length, double breadth);
void printDimensions();
};
#endif
hexagon.cpp
#include <iostream>
#include "hexagon.h"
//#include "polygon.cpp"
using namespace std;
hexagon::hexagon(double side) : polygon(6)
{
dimensions = side
}
hexagon::hexagon(const hexagon* other) : polygon(other)
{
dimensions = other -> dimensions;
}
double hexagon::calcArea()
{
double area = dimensions * dimensions * 6 / (4 * tan ( 3.14159265 / 6 ));
return area;
}
double hexagon::calcPerimeter()
{
return 6 * dimensions;
}
void hexagon::setDimention(double side)
{
dimensions = side;
}
void hexagon::printDimensions()
{
cout << "sides: " << dimensions << endl;
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.