What is Operator Overloading?

#include <iostream>
#include <string>
using namespace std;

int main(){
	string s1 = "ECE";
	string s2 = "244";
	// to concatenate them, we can simply add them
	string s3 = s1 + s2;
}

We’ve just done an operator overloading with +

• Normally, we use + to add numbers
• Now, we’ve overloaded the + operator with strings

Custom Class Example

class complex{
	private:
		double real;
		double img;
	public:
		// our first constructor... the default one
		complex(){
			real = 0;
			img = 0;
		}
		// our second constructor, where user defines the values for Re and Im
		complex(double r, double i){
			real = r;
			img = i;
		}
}

int main(){
	complex x(3, 4);
	complex y(5, 6);
	complex z;
	// can I say the following?
	z = x + y; // I'm calling the "+" operator
}

• when I do z = x + y, the + operator expects 2 numbers, but we’re trying to sum 2 objects
• this will not work at first since we did not create a function that lets the + operator know what to do when it is used to add two objects (complex numbers)
• in short, there is no overloading operator with these parameters

complex complex::operator+(complex rhs){
	complex result(real + rhs.real, img + rhs.img);
	return res;
}

• by “RHS”, we are talking about what’s to the right hand side of the + operator
• member function of the class (it belongs to the complex number class)
• complex is the return type
• complex is the scope
• operator+ is the operator itself that I’m going to overload

z = x + y;
z = x.operator+(y);

Making it more secure

1. Passing the object as a reference will make the function less secure in terms of changes that might affect the object.
   1. Solution: make the RHS object const
2. operator+ should not change data members of the object
   1. Solution: make the return object const