Assignment Overloading

[ileashipa7]

Can some one help with this assignment, new to C++ AND NEED to improve my code below to overload the addition operator, the is equal to operator, the equal to operator for an abstract data type, and perform a class to built-in conversion.Program requirements at the bottom page

 #include <iostream>
using namespace std;
// class declaration section
class Fraction
{
private:
	int Numerator;
	int Denominator;
public:
	Fraction(); // default constructor
	Fraction(int, int); //overloaded constructor
	void setNumerator(int); 
	int getNumerator();
	void setDenominator(int);
	int getDenominator();
};
// class implementation section//
Fraction::Fraction()//default constructor
{
	//assign the Numerator and Denominator to 1
	Numerator = 1;
	Denominator = 1;
}
Fraction::Fraction(int num, int den)//overloaded constructor
{
	//assign Numerator to value passed for the numerator
	Numerator = num;
	//assign the Denominator to 1 if the value passed to the function is 0
	if (den == 0)
		Denominator = 1;//set denominator to 1 
	//otherwise assign the value passed to the Denominator
	else
		Denominator = den;
}
	
void Fraction::setNumerator(int numeratorArg){		
		Numerator = numeratorArg;
}
int Fraction::getNumerator(){
	return Numerator;
}
void Fraction::setDenominator(int denominatorArg){
	if (denominatorArg > 1){
		Denominator = denominatorArg;
	}
	else if (denominatorArg == 0){
		Denominator = 1; //assign to one if value passed to functino is 0
	}
}
int Fraction::getDenominator(){
	return Denominator;
}
int main()
{
	Fraction F1, F2(3, 4); //instantiate 2 Fraction objects
	cout << "Value of the first Fraction object is " << F1.getNumerator() << "/" << F1.getDenominator() << endl;
	cout << "Value of the second Fraction object is " << F2.getNumerator() << "/" << F2.getDenominator() << endl;
	//change the values of one of the Fraction objects
	F2.setNumerator(8);
	F2.setDenominator(5);
	cout << "\nAfter changing the values of the second fraction object" << endl;
	cout << "Value of the second Fraction object is " << F2.getNumerator() << "/" << F2.getDenominator() << endl;
	return 0;
}

Program Requirements:
Modify the Fraction class created in the previous assignment.
Include an overloaded equality operator (==) in the Fraction class that tests two Fraction objects for equality. This function should return back true if the two Fraction objects are equal and false if the two Fraction objects are not equal. The two Fraction objects are equal if the value of the numerator data members are equal and the value of the denominator data members are equal.
Include an overloaded assignment operator (=) in the Fraction class that assigns one Fraction object to another. The return type of this operator function should be a Fraction object to allow multiple assignments such as frac1 = frac2 = frac3; You must write the code for this operator, you cannot use the default assignment operator the C++ compiler will build in the absence of one (page 499).
Include an overloaded addition operator, operator+, that will add two Fraction objects together. This function will return back a new Fraction object that is the sum of two existing Fraction objects.
Include a class to built-in conversion that will return the value of a Fraction object as a double. Divide the numerator by the denominator to get this result.
Make sure all your methods are defined in the implementation section of the class. Do not use any inline member functions. Do not print from within the Fraction class.
Steps 8 through 14 below all apply to the main function.
Prompt the user for a numerator and denominator. Enter these from the keyboard. Use the appropriate constructor and/or functions to create a Fraction object using the values input.
Prompt the user for a second numerator and denominator. Enter these from the keyboard. Use the appropriate constructor and/or functions to create a second Fraction object using the values input.
Use the overloaded == operator to display a message indicating whether the two Fraction objects from steps 8 and 9 are the same or different.
Use the overloaded addition operator to add the two Fraction objects together and display the values of the resulting Fraction object.
Use the overloaded assignment operator to assign the first Fraction object created in step 8 to the second Fraction object created in step 9.
Use the overloaded == operator again to display a message indicating whether the two Fraction objects are the same or different.
Call the class to built-in conversion function created in step 5 to convert one of the Fraction objects to a double and display this value.

[Bdanielz]

So here is an example of me overloading a "bucket" class for ==, + and =
let us know if you have any questions.

#include <iostream>

class Bucket {
private:
    int drops_of_water;
public:
    Bucket(int drops_of_water) {
        this->drops_of_water = drops_of_water;
    }

    int get_drops_of_water() const {
        return drops_of_water;
    }

    bool operator==(const Bucket &other) const {
        return (this->drops_of_water == other.drops_of_water);
    }

    Bucket operator+(const Bucket &other) const {
        return (this->drops_of_water + other.drops_of_water);
    }

    Bucket &operator=(const Bucket &aBuket) {
        // do the copy
        this->drops_of_water = aBuket.drops_of_water;

        // return the existing object
        return *this;
    }

};
void isEqual(const Bucket &a, const Bucket &b);
using namespace std;

int main() {
    Bucket a (1), b (2), c (1);
    if (a == c) {
        cout << "a is equal to c" << endl;
    }
    a = a + a;
    if (a == b) {
        cout << "a is equal to b" << endl;
    }
    return 0;
}

a is equal to c
a is equal to b