// overload1.cpp		By: Aiman Hanna -  ©1993-2006 Aiman Hanna

// This program illustrates the concept of function overloading. Function overloading 
// refers to the ability to have different functions with the same name. Although 
// more than one function have the same name, upon calling any of these functions the
// compiler is capable of determining which one of these functions is to be executed.
// The compiler performs that by verifying the type of the passed parameters, and find
// the function that provides the best match. You should notice that:
//	1) If more than one function provide a best match, the compiler will NOT be
// 	   able to determine which one of these function should run, so an error is 
// 	   generated. 
//	2) The return type is NOT used by the compiler to distinguish between 
// 	   overloaded functions. As an example, the following is not a correct function
// 	   overloading: 	int fun(int, int); 	and   double fun(int, int);
//	3) Although some of the overloaded functions may cause a potential (eventual)
// 	   confusion to the compiler, the compiler may allow such function overloading
// 	   as long as there are no calls within the program that lead this confusion to 
// 	   take place. You should always make sure that you use overloaded functions
//	   correctly. 
//	The following programs will illustrate the above points.

// Key Points: 		1) Function overloading



#include "overload1.h"

MathOperations::MathOperations( void )
{
 	ires = 0;
 	dres1 = dres2 = 0;
}



int MathOperations::divide ( int i1, int i2 )
{
 	// divide the 1st passed parameter by the second one, and assign the result to 
 	// the private data ires. The function assumes that the second parameter will 
 	// never be 0

 	cout << "\n Executing an integer type division. " << endl;
 	ires = int(i1/i2);

 	cout << " The result of dividing " <<i1 << " / " << i2 << " is: " 
 	     << ires << endl;

 	return ires;
}



double MathOperations::divide ( double d1, double d2)
{
 	// divide the 1st passed parameter by the second one, and assign the result to 
 	// the private data dres1. The function assumes that the second parameter will 
 	// never be 0

	cout << "\n Executing a double type division. " << endl;
	dres1 = d1/d2;
	cout << " The result of dividing " << d1 << " / " << d2 << " is: " 
 	<< dres1 << endl;

	return dres1;
}



double MathOperations::divide (double d1, int i1, double d2)
{
 	// Add the first two passed parameters and then divide the result by the 3rd
 	// parameter. Assign the final result to the private data dres2. The function 
 	// assumes that the third parameter will never be 0

 	cout << "\n Executing an addition then a double type division. " << endl;
 	dres2 = (d1 + i1) / d2;
 	cout << " The result of dividing " << d1 + i1 << " / " << d2 << " is: " 
 	     << dres2 << endl;

	return dres2;
}


int main()
{
	MathOperations m1;
	m1.divide(34.2, 3.5);
	m1.divide(10, 4);
	m1.divide(10.5, 4, 3.2);
	m1.divide(10, 4, 3);
	m1.divide(10.1, 4.4, 2.5);  		// this is line 91

	return 0;
}



// the result of compiling the program: 
/*
On HP-UX
CC: "overload1.cpp", line 91: warning: argument 2: double  passed as int  (142)

On VC++
overload1.cpp(91) : warning C4244: 'argument' : conversion from 'const double' to 'int', possible loss of data
*/

// The result of running the program: 
/*
  
 Executing a double type division.
 The result of dividing 34.2 / 3.5 is: 9.77143

 Executing an integer type division.
 The result of dividing 10 / 4 is: 2

 Executing an addition then a double type division.
 The result of dividing 14.5 / 3.2 is: 4.53125

 Executing an addition then a double type division.
 The result of dividing 14 / 3 is: 4.66667

 Executing an addition then a double type division.
 The result of dividing 14.1 / 2.5 is: 5.64

*/