FeetInches Program/overloading/modify operators

my name is kenny and i am teaching myself c++ at the moment. The prompt i use i get from my friend's class. here is the prompt. I need to create a FeetInches class and modify it using relational overloading operators. I have got both the .cpp and .h files working. I just need to create another .cpp file that tests the program. here is the question for each part. please let me know if i have done everything correctly. the second .cpp file needs to be labeled as lab feetinches. it must also call/test every "member function".

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 +
bool operator <= (const FeetInches &);
bool operator >= (const FeetInches &);
bool operator != (const FeetInches &);
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 ==

// copy constructor
FeetInches (FeetInches &right)
{
    feet = right.feet;
    inches = right.inches;
}

//multiply function 
FeetInches multiply(FeetInches obj)
{
    FeetInches temp;
    temp.feet = feet * obj.feet;
    temp.inches = inches * obj.inches;
    temp.simplify();
    return temp;
}

                                            // Conversion functions
operator double();
operator int();

// Friends
friend ostream &operator << (ostream &, const FeetInches &);
friend istream &operator >> (istream &, FeetInches &);
};

#endif#pragma once

feetinches.cpp

// Implementation file for the FeetInches class
#include <cstdlib>  // Needed for abs()
#include "kenny_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 the <= operator.               *
//**********************************************

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 the >= operator.               *
//**********************************************

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 the != operator.               *
//**********************************************

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;
}

Any help will be much appreciated. Thank you in advance.