home / study / engineering / computer science / questions and answers / project
ID: 3690638 • Letter: H
Question
home / study / engineering / computer science / questions and answers / project description: you will be creating a program ...
Your question has been answered! Rate it below.
Let us know if you got a helpful answer.
Question
Project Description:
You will be creating a program that models the relationship between different types of
shapes. You will use inheritance to describe these relationships. You will also create simple
recursive functions that manipulate the objects you create. Each class will be separated into two
files: a header and source file. Below are the specifications for each class:
Class Shape Basics (shape.hpp and shape.cpp):
The class must be named Shape
The class must have the following members:
int numSides
Default constructor that can take a single int
will assign the passed int to numSides
if no value is passed numSides must equal 1
A copy constructor
double area()
return 1
double perimeter()
return 1
int getSide()
will return the value of numSides
Any helper functions you deem appropriate
Class Circle Basics (circle.hpp and circle.cpp):
The class must be named Circle
The class must inherit from Shape
The class must have the following members:
double radius
Default constructor that can take a single double
must call Shape’s constructor and send it 0
will assign the passed double to radius
if no value is passed radius must equal 1
A copy constructor
double area() Note that this is overloaded from Shape
if the radius is equal to 1 return 0
return the area of the circle. Use 3.14 for pi (pi*radius^2)
double perimeter() Note that this is overloaded from Shape
if the radius is equal to 1
return 0
return the perimeter/circumference of the circle. Use 3.14 for pi
(2*pi*radius)
void incSides(int n)
will increase the length of the radius n times recursively (see description
below)
Any helper functions you deem appropriate
Class Rectangle Basics (rectangle.hpp and rectangle.cpp):
The class must be named Rectangle
The class must inherit from Shape
The class must have the following members:
double side1
double side2
Default constructor that can take two doubles
must call Shape’s constructor and send it 4
will assign the first argument to side1
will assign the second argument to side2
if no value is passed either argument they must equal 1
A copy constructor
double area() Note
that this is overloaded from Shape
if any of the sides are equal to 1
return 0
return the area of the rectangle: width*length
double perimeter() Note
that this is overloaded from Shape
if any of the sides are equal to 1
return 0
return the perimeter of the rectangle: 2*width + 2*length
void incSides(int n)
will increase the length of each side n times recursively (see description
below)
Any helper functions you deem appropriate
Class Triangle Basics (triangle.hpp and triangle.cpp):
The class must be named Triangle
The class must inherit from Shape
The class must have the following members:
double side1
double side2
double side3
Default constructor that can take three doubles
must call Shape’s constructor and send it 3
will assign the first argument to side1
will assign the second argument to side2
will assign the third argument to side3
if no value is passed either argument they must equal 1
A copy constructor
double area() Note
that this is overloaded from Shape
if any of the sides are equal to 1
return 0
return the area of the triangle: use Herons Formula https://
www.mathsisfun.com/geometry/heronsformula.
html
double perimeter() Note
that this is overloaded from Shape
if any of the sides are equal to 1
return 0
return the perimeter of the triangle: side1 + side2 + side3
void incSides(int n)
will increase the length of each side n times recursively (see description
below)
Any helper functions you deem appropriate
It is up to you to determine which members need to be public, private, or protected . It is
NOT acceptable to make everything public . If it doesn’t need to be public then it should be
protected or private . If it doesn’t need to be protected it should be private .
For the function incSides(int n) you must come up with a recursive solution to increase
each side n times. Yes, this is the same as multiplying each side by n. Yes, this could be done
in a loop very easily. No, you may not do either of those things. This is to practice recursion so
your solution must use recursion. Remember that each recursive function needs to have a base
case(s) and a recursive step. We will be checking to ensure your solution is recursive.
Explanation / Answer
circle.hpp
#ifndef CIRCLE_HPP
#define CIRCLE_HPP
//includes
#include "shape.hpp"
class Circle : public Shape
{
private:
double radius;
public:
Circle(); //default constructor
Circle(double); //constructor with parameter
Circle(const Circle &); //copy constructor
~Circle(); //deconstructor
double getRadius(); //returns radius
void setRadius(double); //sets radius
double area(); //returns area
double perimeter(); //returns perimeter
void incSides(int); //increases length of the radius recursively n times
};
#endif
circle.cpp
//includes
#include <iostream>
#include "circle.hpp"
//usings
using std::cout;
using std::endl;
//default constructor
Circle::Circle() : Shape(0)
{
radius = -1;
}
//normal case constructor
Circle::Circle(double radiusIn = -1) : Shape(0)
{
radius = radiusIn;
}
//copy constructor
Circle::Circle(const Circle &circleIn)
{
radius = circleIn.radius;
}
//deconstructor
Circle::~Circle()
{
//cout << "Circle deconstructor has run.";
}
//gets radius
double Circle::getRadius()
{
return radius;
}
//sets radius
void Circle::setRadius(double radiusIn)
{
radius = radiusIn;
}
//returns area
double Circle::area()
{
if (radius == -1) return 0;
else
{
return 3.14 * (radius * radius);
}
}
//returns perimeter
double Circle::perimeter()
{
if (radius == -1) return 0;
else
{
return 2 * 3.14 * radius;
}
}
//increases length the radius recursively n times
void Circle::incSides(int n)
{
if (n == 1)
{
return;
}
incSides(n - 1);
radius += radius;
}
main.cpp
#include <iostream>
#include "circle.hpp"
#include "rectangle.hpp"
#include "triangle.hpp"
using std::cout;
using std::endl;
int main()
{
//circle tests
Circle newCircle = Circle(2);
cout << "newCircle radius is: " << newCircle.getRadius() << endl;
newCircle.incSides(3);
cout << "newCircle radius is: " << newCircle.getRadius() << endl;
std::cin.get();
//rectangle tests
Rectangle newRectangle = Rectangle(2, 3);
cout << "newRectangle side1, side2: " << newRectangle.getSide1() << " , " << newRectangle.getSide2() << endl;
newRectangle.incSides(3);
cout << "newRectangle side1, side2: " << newRectangle.getSide1() << " , " << newRectangle.getSide2() << endl;
std::cin.get();
//triangle tests
Triangle newTriangle = Triangle(5, 5, 5);
cout << "newTriangle side1, side2, side3: " << newTriangle.getSide1() << " , " << newTriangle.getSide2() << " , " << newTriangle.getSide3() << endl;
cout << "newTriangle's area: " << newTriangle.area() << endl;
newTriangle.incSides(3);
cout << "newTriangle side1, side2, side3: " << newTriangle.getSide1() << " , " << newTriangle.getSide2() << " , " << newTriangle.getSide3() << endl;
std::cin.get();
return 0;
}
rectangle.cpp
//includes
#include <iostream>
#include "rectangle.hpp"
//usings
using std::cout;
//default constructor
Rectangle::Rectangle() : Shape(4)
{
side1 = -1;
side2 = -1;
}
//normal case constructor w/default values
Rectangle::Rectangle(double side1In = -1, double side2In = -1) : Shape(4)
{
side1 = side1In;
side2 = side2In;
}
//copy constructor
Rectangle::Rectangle(const Rectangle &rectangleIn)
{
side1 = rectangleIn.side1;
side2 = rectangleIn.side2;
}
//deconstructor
Rectangle::~Rectangle()
{
//cout << "Rectangle deconstructor has run.";
}
//increases each side recursively n times
void Rectangle::incSides(int n)
{
if (n == 1)
{
return;
}
incSides(n - 1);
side1 += side1;
side2 += side2;
}
//calculates and returns area
double Rectangle::area()
{
if (side1 == -1 || side2 == -1) return 0;
else
{
return side1 * side2;
}
}
//calculates and returns perimeter
double Rectangle::perimeter()
{
if (side1 == -1 || side2 == -1) return 0;
else
{
return (2 * side1) + (2 * side2);
}
}
//getters for testing
double Rectangle::getSide1()
{
return side1;
}
double Rectangle::getSide2()
{
return side2;
}
rectangle.hpp
#ifndef RECTANGLE_HPP
#define RECTANGLE_HPP
//includes
#include "shape.hpp"
class Rectangle : public Shape
{
private:
double side1;
double side2;
public:
Rectangle(); //default constructor
Rectangle(double, double); //constructor with parameters
Rectangle(const Rectangle &); //copy constructor
~Rectangle(); //deconstructor
double area(); //returns area
double perimeter(); //returns perimeter
void incSides(int); //increases each side recursively n times
double getSide1(); //returns side1 value
double getSide2(); //returns side2 value
};
#endif
shape.cpp
//includes
#include <iostream>
#include "shape.hpp"
//usings
using std::cout;
using std::endl;
//default constructor
Shape::Shape()
{
numSides = -1;
}
//normal case constructor
Shape::Shape(int sidesIn = -1)
{
numSides = sidesIn;
}
//copy constructor
Shape::Shape(const Shape &shapeIn)
{
numSides = shapeIn.numSides;
}
//deconstructor
Shape::~Shape()
{
// << "Shape deconstructor has run." << endl;
}
//function that will be typically overrided by childs function
double Shape::area()
{
return -1;
}
//function that will be typically overrided by childs function
double Shape::perimeter()
{
return -1;
}
//function that returns the number of sides
int Shape::getSides()
{
return numSides;
}
shape.hpp
#ifndef SHAPE_HPP
#define SHAPE_HPP
//includes
class Shape
{
protected:
int numSides;
public:
Shape(); //default constructor
Shape(int); //constructor with parameter
Shape(const Shape &); //copy constructor
~Shape(); //deconstructor
double area(); //to be overridden by child classes
double perimeter(); //to be overridden by child classes
int getSides(); //returns the number of sides
};
#endif
triangle.cpp
//includes
#include <iostream>
#include "triangle.hpp"
//usings
using std::cout;
//default constructor
Triangle::Triangle() : Shape(3)
{
side1 = -1;
side2 = -1;
side3 = -1;
}
//normal case constructor w/default values
Triangle::Triangle(double side1In = -1, double side2In = -1, double side3In = -1) : Shape(3)
{
side1 = side1In;
side2 = side2In;
side3 = side3In;
}
//copy constructor
Triangle::Triangle(const Triangle &triangleIn)
{
side1 = triangleIn.side1;
side2 = triangleIn.side2;
side3 = triangleIn.side3;
}
//deconstructor
Triangle::~Triangle()
{
//cout << "Rectangle deconstructor has run.";
}
//increases each side recursively n times
void Triangle::incSides(int n)
{
if (n == 1)
{
return;
}
incSides(n - 1);
side1 += side1;
side2 += side2;
side3 += side3;
}
//calculates and returns area
double Triangle::area()
{
if (side1 == -1 || side2 == -1 || side3 == -1) return 0;
else
{
double s = (side1 + side2 + side3) / 2;
double area = sqrt(s* (s - side1)*(s - side2)*(s - side3));
return area;
}
}
//calculates and returns perimeter
double Triangle::perimeter()
{
if (side1 == -1 || side2 == -1 || side3 == -1) return 0;
else
{
return side1 + side2 + side3;
}
}
//getters for testing
double Triangle::getSide1()
{
return side1;
}
double Triangle::getSide2()
{
return side2;
}
double Triangle::getSide3()
{
return side3;
}
triangle.hpp
#ifndef TRIANGLE_HPP
#define TRIANGLE_HPP
//includes
#include "shape.hpp"
class Triangle : public Shape
{
private:
double side1;
double side2;
double side3;
public:
Triangle(); //default constructor
Triangle(double, double, double); //constructor with parameters
Triangle(const Triangle &); //copy constructor
~Triangle(); //deconstructor
double area(); //returns area
double perimeter(); //returns perimeter
void incSides(int); //increases each side recursively n times
double getSide1(); //returns side1 value
double getSide2(); //returns side2 value
double getSide3(); //returns side3 value
};
#endif
sample output
newCircle radius is: 2
newCircle radius is: 8
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.