Redo Programming Exercise 3 by overloading the operators as nonmembers of the class boxType Write a program that tests the operations of the class boxType ********************************* boxType.h ********************************* #ifndef boxType_H #define boxType_H #include "rectangleType.h" class boxType: public rectangleType { //Overload the stream insertion and extraction operators friend ostream& operator<<(ostream&, const boxType &); friend istream& operator>>(istream&, boxType &); public: void setDimension(double l, double w, double h); //Function to set the length, width, and height //of the box. //Postcondition: length = l; width = w; height = h; double getHeight() const; //Function to return the height of the box. //Postcondition: The value of height is returned. double area() const; //Function to return the surface area of the box. //Postcondition: The surface area of the box is // calculated and returned. double volume() const; //Function to return the volume of the box. //Postcondition: The volume of the box is // calculated and returned. boxType(); //Default constructor //Postcondition: length = 0; width = 0; height = 0; boxType(double l, double w, double h); //Constructor with parameters //Postcondition: length = l; width = w; height = h; //Overload the arithmetic operators boxType operator + (const boxType &) const; boxType operator - (const boxType &) const; boxType operator * (const boxType&) const; //Overload the increment and decrement operators boxType operator ++ (); //pre-increment boxType operator ++ (int); //post-increment boxType operator -- (); //pre-decrement boxType operator -- (int); //post-decrement //Overload the relational operators bool operator == (const boxType&) const; bool operator != (const boxType&) const; bool operator <= (const boxType&) const; bool operator < (const boxType&) const; bool operator >= (const boxType&) const; bool operator > (const boxType&) const; protected: double height; }; #endif ************************* boxType.cpp ************************* #include #include #include "rectangleType.h" #include "boxType.h" using namespace std; void boxType::setDimension(double l, double w, double h) { rectangleType::setDimension(l, w); if (h >= 0) height = h; else height = 0; } double boxType::getHeight() const { return height; } double boxType::area() const { return 2 * (getLength() * getWidth() + getLength() * height + getWidth() * height); } double boxType::volume() const { return rectangleType::area() * height; } boxType::boxType() { height = 0.0; } boxType::boxType(double l, double w, double h) : rectangleType(l, w) { if (h >= 0) height = h; else height = 0; } boxType boxType::operator + (const boxType & box) const { boxType tempBox; tempBox.length = length + box.length; tempBox.width = width + box.width; tempBox.height = height + box.height; return tempBox; } boxType boxType::operator - (const boxType & box) const { boxType tempBox; assert(length >= box.length && width >= box.width && height >= box.height); tempBox.length = length + box.length; tempBox.width = width + box.width; tempBox.height = height + box.height; return tempBox; } boxType boxType::operator * (const boxType & box) const { boxType tempBox; tempBox.length = length * box.length; tempBox.width = width * box.width; tempBox.height = height * box.height; return tempBox; } boxType boxType::operator ++ () { ++length; ++width; ++height; return *this; //return the incremented value of the object } boxType boxType::operator ++ (int u) { boxType temp = *this; //use this pointer to copy //the value of the object length++; width++; height; return temp; //return the old value of the object } boxType boxType::operator--() { //Decrement the length and width assert(length >= 1 && width >= 1 && height >= 1); --length; --width; --height; return *this; //return the incremented value of the object } boxType boxType::operator -- (int u) { boxType temp = *this; //use this pointer to copy //the value of the object //Decrement the length and width assert(length >= 1 && width >= 1 && height >= 1); length--; width--; height--; return temp; //return the old value of the object } bool boxType::operator == (const boxType& box) const { return (volume() == box.volume()); } bool boxType::operator != (const boxType& box) const { return (volume() != box.volume()); } bool boxType::operator <= (const boxType& box) const { return (volume() <= box.volume()); } bool boxType::operator < (const boxType& box) const { return (volume() < box.volume()); } bool boxType::operator >= (const boxType& box) const { return (volume() >= box.volume()); } bool boxType::operator > (const boxType& box) const { return (volume() > box.volume()); } ostream& operator<<(ostream& osObject, const boxType& box) { osObject << "Length = " << box.length << "; Width = " << box.width << "; Height = " << box.height; return osObject; } istream& operator>>(istream& isObject, boxType& box) { isObject >> box.length >> box.width >> box.height; return isObject; } ******************* rectangleType.h ******************* #ifndef H_rectangleType #define H_rectangleType #include using namespace std; class rectangleType { //Overload the stream insertion and extraction operators friend ostream& operator<<(ostream&, const rectangleType &); friend istream& operator>>(istream&, rectangleType &); public: void setDimension(double l, double w); double getLength() const; double getWidth() const; double area() const; double perimeter() const; //Overload the arithmetic operators rectangleType operator + (const rectangleType &) const; rectangleType operator - (const rectangleType &) const; rectangleType operator * (const rectangleType&) const; //Overload the increment and decrement operators rectangleType operator ++ (); //pre-increment rectangleType operator ++ (int); //post-increment rectangleType operator -- (); //pre-decrement rectangleType operator -- (int); //post-decrement //Overload the relational operators bool operator == (const rectangleType&) const; bool operator != (const rectangleType&) const; bool operator <= (const rectangleType&) const; bool operator < (const rectangleType&) const; bool operator >= (const rectangleType&) const; bool operator > (const rectangleType&) const; //constructors rectangleType(); rectangleType(double l, double w); protected: double length; double width; }; #endif ************************** rectangleType.cpp ************************** #include #include #include "rectangleType.h" using namespace std; void rectangleType::setDimension(double l, double w) { if (l >= 0) length = l; else length = 0; if (w >= 0) width = w; else width = 0; } double rectangleType::getLength() const { return length; } double rectangleType::getWidth()const { return width; } double rectangleType::area() const { return length * width; } double rectangleType::perimeter() const { return 2 * (length + width); } rectangleType::rectangleType(double l, double w) { setDimension(l, w); } rectangleType::rectangleType() { length = 0; width = 0; } rectangleType rectangleType::operator++() { //increment the length and width ++length; ++width; return *this; //return the incremented value of the object } rectangleType rectangleType::operator++(int u) { rectangleType temp = *this; //use this pointer to copy //the value of the object //increment the length and width length++; width++; return temp; //return the old value of the object } rectangleType rectangleType::operator--() { //Decrement the length and width assert(length != 0 && width != 0); --length; --width; return *this; //return the incremented value of the object } rectangleType rectangleType::operator--(int u) { rectangleType temp = *this; //use this pointer to copy //the value of the object //Decrement the length and width assert(length != 0 && width != 0); length--; width--; return temp; //return the old value of the object } rectangleType rectangleType::operator+ (const rectangleType& rectangle) const { rectangleType tempRect; tempRect.length = length + rectangle.length; tempRect.width = width + rectangle.width; return tempRect; } rectangleType rectangleType::operator- (const rectangleType& rectangle) const { rectangleType tempRect; assert(length >= rectangle.length && width >= rectangle.width); tempRect.length = length - rectangle.length; tempRect.width = width - rectangle.width; return tempRect; } rectangleType rectangleType::operator*(const rectangleType& rectangle) const { rectangleType tempRect; tempRect.length = length * rectangle.length; tempRect.width = width * rectangle.width; return tempRect; } bool rectangleType::operator== (const rectangleType& rectangle) const { return (area() == rectangle.area()); } bool rectangleType::operator!= (const rectangleType& rectangle) const { return (area() != rectangle.area()); } bool rectangleType::operator<= (const rectangleType& rectangle) const { return (area() <= rectangle.area()); } bool rectangleType::operator< (const rectangleType& rectangle) const { return (area() < rectangle.area()); } bool rectangleType::operator>= (const rectangleType& rectangle) const { return (area() >= rectangle.area()); } bool rectangleType::operator> (const rectangleType& rectangle) const { return (area() > rectangle.area()); } ostream& operator<<(ostream& osObject, const rectangleType& rectangle) { osObject << "Length = " << rectangle.length << "; Width = " << rectangle.width; return osObject; } istream& operator>>(istream& isObject, rectangleType& rectangle) { isObject >> rectangle.length >> rectangle.width; return isObject; }