One neat thing you can do in C++ that is not present in Java is the ability to overload operators like * / + - % ^ & | ! , = < > <= >= ++ -- << >> == != && || *= /= %= ^= &= |= += -= <<= >>= -> ->* [] () new delete.

Here, I'll go over a few common ones: =, +. Why only addition you ask? Because one you understand one arithmetic operator, you understand them all (just change the operator )

This example was inspired from this thread.


Before we get too ahead of ourselves, the purpose of overloading an operator is to allow the user/programmer to have statements such as:

objectOne = objectTwo;
objectOne = objectTwo / objectThree;
//so on and so forth

Without overloading these operators the compiler will not only complain, but any work around could be cumbersome and ultimately frivolous. Having that said, our class:

class JarType {
private:
	int numUnits;
public:
	JarType()				{ numUnits = 0; };
	JarType(int n)			{ numUnits = n; };
	int getUnits()			{ return numUnits;};
};

Not overly complicated, which is good for our purposes. Notice that we have a default constructor and an additional one that takes an integer as a parameter. There's s only one data member numUnits, an integer. We have an accessor function since we want to keep the data private. Now with this class definition the following code will not work:

int main()
{
	JarType jarOne, jarTwo(10), jarThree(15);
	jarOne = jarTwo;
	cout << jarOne.getUnits()		<< endl; //assignment operator jarOne.numUnits now equals 10
	jarOne = (jarTwo + jarThree);
	cout << jarOne.getUnits()		<< endl; // addition operator jarOne.numUnits now equals 25
	return 0;
}

The compiler will complain at you about nearly every line of that code. Mainly because it does not know how to react to setting one JarType to another or how to assign a JarType to the addition of two other JarTypes. So, lets talk about how to solve this:

JarType operator +(const JarType& secondJar) 
{
		JarType temp;
		temp.numUnits = numUnits + secondJar.numUnits;
		return temp;
}

The function will return an object of this class, the parameter is what comes to the right of the '+' sign. Often it will be called rhs for "right hand side". We declare a temporary variable (aptly named) and then assign its data member to the addition of the left hand side's numUnits (simply written as numUnits, in java one would write this.numUnits, same principle) and the right hand side (the parameter)'s numUnits. We then return the temp. The left hand side operator's numUnits will now be equal to temp's. Temp goes out of scope so we don't need to worry about cleaning it up, it was declared on the stack, You might be asking, why don't we just declare this void and simply add the two term? Well, what if we want to add two objects and then assign the result to another object without permanently modifying the added objects? See below:

void operator =(const JarType& secondJar)
{
		numUnits = secondJar.numUnits; //assign data member from one to another
}

Overloading equals will assign the private data from the parameter (right hand side) to the left hand side. Alternately we could return a JarType for this, but then we'd have to get into copy constructors and that goes a little out of the scope of this single blog post (perhaps more on that later). Notice in each example that the parameter is declared const. That is to ensure that the data cannot be accidentally or inadvertently modified. We are protecting ourselves from ourselves.

Happy Coding!

--KYA


For further reading: See here