Modify the FeetInches class discussed in this chapter so it overloads the follow

Question

Modify the FeetInches class discussed in this chapter so it overloads the following operators:

<=

>=

!=

Demonstrate the class's capabilities in a simple program.

Grading:
1. Prototypes for three new operators added to FeetInches.h file

2. Code for overloaded >= added to FeetInches.cpp file.

Has proper return value and object parameter

Checks if the current object is greater than or equal to the parameter and returns.

3. Code for overloaded <= added to FeetInches.cpp file.

Has proper return value and object FeetInches parameter

Checks if the current object is less than or equal to the parameter and returns.

4. Code for overloaded != added to FeetInches.cpp file.

Has proper return value and object parameter

Checks if the current object is equal to the parameter and returns.



These are my codes for the files that I have so far:

#include <iostream>

#include "FeetInches.h"

using namespace std;

int main()

{

// Create three FeetInches objects.

FeetInches one, two, three;

// Get a distance for the first object.

cout << "Enter a distance in feet and inches: ";

cin >> one;

// Get a distance for the second object.

cout << "Enter another distance in feet and inches: ";

cin >> two;

// Test the != operator.

if (one != two)

cout << "The two are not equal. ";

// Test the >= operator.

if (one >= two)

cout << one << " is >= " << two << endl;

// Test the <= operator.

if (one <= two)

cout << one << " is <= " << two << endl;

return 0;

}

FeetInches.h:

// Specification file for the FeetInches class

#ifndef FEETINCHES_H

#define FEETINCHES_H

#include <iostream>

using namespace std;

class FeetInches; // Forward Declaration

// Function Prototypes for Overloaded Stream Operators

ostream &operator << (ostream &, const FeetInches &);

istream &operator >> (istream &, FeetInches &);

// The FeetInches class holds distances or measurements

// expressed in feet and inches.

class FeetInches

{

private:

int feet; // To hold a number of feet

int inches; // To hold a number of inches

void simplify(); // Defined in FeetInches.cpp

public:

// Constructor

FeetInches(int f = 0, int i = 0)

{ feet = f;

inches = i;

simplify(); }

// Mutator functions

void setFeet(int f)

{ feet = f; }

void setInches(int i)

{ inches = i;

simplify(); }

// Accessor functions

int getFeet() const

{ return feet; }

int getInches() const

{ return inches; }

// Overloaded operator functions

FeetInches operator + (const FeetInches &); // Overloaded +

FeetInches operator - (const FeetInches &); // Overloaded -

FeetInches operator ++ (); // Prefix ++

FeetInches operator ++ (int); // Postfix ++

bool operator > (const FeetInches &); // Overloaded >

bool operator < (const FeetInches &); // Overloaded <

bool operator == (const FeetInches &); // Overloaded ==

// Conversion functions

operator double();

operator int();

// Friends

friend ostream &operator << (ostream &, const FeetInches &);

friend istream &operator >> (istream &, FeetInches &);

};

#endif

FeetInches.cpp

// Implementation file for the FeetInches class

#include <cstdlib> // Needed for abs()

#include "FeetInches.h"

//************************************************************

// Definition of member function simplify. This function *

// checks for values in the inches member greater than *

// twelve or less than zero. If such a value is found, *

// the numbers in feet and inches are adjusted to conform *

// to a standard feet & inches expression. For example, *

// 3 feet 14 inches would be adjusted to 4 feet 2 inches and *

// 5 feet -2 inches would be adjusted to 4 feet 10 inches. *

//************************************************************

void FeetInches::simplify()

{

if (inches >= 12)

{

feet += (inches / 12);

inches = inches % 12;

}

else if (inches < 0)

{

feet -= ((abs(inches) / 12) + 1);

inches = 12 - (abs(inches) % 12);

}

}

//**********************************************

// Overloaded binary + operator. *

//**********************************************

FeetInches FeetInches::operator + (const FeetInches &right)

{

FeetInches temp;

temp.inches = inches + right.inches;

temp.feet = feet + right.feet;

temp.simplify();

return temp;

}

//**********************************************

// Overloaded binary - operator. *

//**********************************************

FeetInches FeetInches::operator - (const FeetInches &right)

{

FeetInches temp;

temp.inches = inches - right.inches;

temp.feet = feet - right.feet;

temp.simplify();

return temp;

}

//*************************************************************

// Overloaded prefix ++ operator. Causes the inches member to *

// be incremented. Returns the incremented object. *

//*************************************************************

FeetInches FeetInches::operator ++ ()

{

++inches;

simplify();

return *this;

}

//***************************************************************

// Overloaded postfix ++ operator. Causes the inches member to *

// be incremented. Returns the value of the object before the *

// increment. *

//***************************************************************

FeetInches FeetInches::operator ++ (int)

{

FeetInches temp(feet, inches);

inches++;

simplify();

return temp;

}

//************************************************************

// Overloaded > operator. Returns true if the current object *

// is set to a value greater than that of right. *

//************************************************************

bool FeetInches::operator > (const FeetInches &right)

{

bool status;

if (feet > right.feet)

status = true;

else if (feet == right.feet && inches > right.inches)

status = true;

else

status = false;

return status;

}

//************************************************************

// Overloaded < operator. Returns true if the current object *

// is set to a value less than that of right. *

//************************************************************

bool FeetInches::operator < (const FeetInches &right)

{

bool status;

if (feet < right.feet)

status = true;

else if (feet == right.feet && inches < right.inches)

status = true;

else

status = false;

return status;

}

//*************************************************************

// Overloaded == operator. Returns true if the current object *

// is set to a value equal to that of right. *

//*************************************************************

bool FeetInches::operator == (const FeetInches &right)

{

bool status;

if (feet == right.feet && inches == right.inches)

status = true;

else

status = false;

return status;

}

//********************************************************

// Overloaded << operator. Gives cout the ability to *

// directly display FeetInches objects. *

//********************************************************

ostream &operator<<(ostream &strm, const FeetInches &obj)

{

strm << obj.feet << " feet, " << obj.inches << " inches";

return strm;

}

//********************************************************

// Overloaded >> operator. Gives cin the ability to *

// store user input directly into FeetInches objects. *

//********************************************************

istream &operator >> (istream &strm, FeetInches &obj)

{

// Prompt the user for the feet.

cout << "Feet: ";

strm >> obj.feet;

// Prompt the user for the inches.

cout << "Inches: ";

strm >> obj.inches;

// Normalize the values.

obj.simplify();

return strm;

}

//*************************************************************

// Conversion function to convert a FeetInches object *

// to a double. *

//*************************************************************

FeetInches::operator double()

{

double temp = feet;

temp += (inches / 12.0);

return temp;

}

//*************************************************************

// Conversion function to convert a FeetInches object *

// to an int. *

//*************************************************************

FeetInches:: operator int()

{

return feet;

}

Help would be greatly appreciated!

Explanation / Answer

bool FeetInches :: operator <= (const FeetInches &obj)

{

bool status;

if(feet < obj.feet)

status = true;

else if(feet == obj.feet && inches <= 0bj.inches)

status = true;

else

status = false;

return status;

}

bool FeetInches :: operator >= (const FeetInches &obj)

{

bool status;

if(feet > obj.feet)

status = true;

else if(feet == obj.feet && inches >= 0bj.inches)

status = true;

else

status = false;

return status;

}

bool FeetInches :: operator != (const FeetInches &obj)

{

bool status;

if(feet == obj.feet && inches == obj.inches)

status = false;

else

status = true;

return status;

}

Related Questions

Navigate

• Browse (All)
• Browse M
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.