Binary operators http://ecomputernotes.com

Binary operators Overloading + operator: class Complex{ private: double real, img; public: … Complex operator +(const Complex & rhs); };

Binary operators Complex Complex::operator +( const Complex & rhs){ Complex t; t.real = real + rhs.real; t.img = img + rhs.img; return t; } http://ecomputernotes.com

Binary operators The return type is Complex so as to facilitate complex statements like: Complex t = c1 + c2 + c3; The above statement is automatically converted by the compiler into appropriate function calls: (c1.operator +(c2)).operator +(c3); http://ecomputernotes.com

Binary operators The binary operator is always called with reference to the left hand argument Example: In c1+c2, c1.operator+(c2) In c2+c1, c2.operator+(c1) http://ecomputernotes.com

Binary operators The above examples don’t handle the following situation: Complex c1; c1 + 2.325 To do this, we have to modify the Complex class http://ecomputernotes.com

Binary operators Modifying the complex class: class Complex{ ... Complex operator+(const Complex & rhs); Complex operator+(const double& rhs); }; http://ecomputernotes.com

Binary operators Complex operator + (const double& rhs){ Complex t; t.real = real + rhs; t.img = img; return t; } http://ecomputernotes.com

Binary operators Now suppose: Complex c2, c3; We can do the following: Complex c1 = c2 + c3; and Complex c4 = c2 + 235.01; http://ecomputernotes.com

Binary operators But problem arises if we do the following: Complex c5 = 450.120 + c1; The + operator is called with reference to 450.120 No predefined overloaded + operator is there that takes Complex as an argument http://ecomputernotes.com

Binary operators Now if we write the following two functions to the class, we can add a Complex to a real or vice versa: Class Complex{ … friend Complex operator + (const Complex & lhs, const double & rhs); friend Complex operator + (const double & lhs, const Complex & rhs); } http://ecomputernotes.com

Binary operators Complex operator +(const Complex & lhs, const double& rhs){ Complex t; t.real = lhs.real + rhs; t.img = lhs.img; return t; } http://ecomputernotes.com

Binary operators Complex operator + (const double & lhs, const Complex & rhs){ Complex t; t.real = lhs + rhs.real; t.img = rhs.img; return t; } http://ecomputernotes.com

Binary operators Class Complex{ … Complex operator + (const Complex &); friend Complex operator + (const Complex &, const double &); friend Complex operator + (const double &, const Complex &); }; http://ecomputernotes.com

Binary operators Other binary operators are overloaded very similar to the + operator as demonstrated in the above examples Example: Complex operator * (const Complex & c1, const Complex & c2); Complex operator / (const Complex & c1, const Complex & c2); Complex operator - (const Complex & c1, const Complex & c2); http://ecomputernotes.com

Assignment operator Consider a string class: class String{ int size; char * bufferPtr; public: String(); String(char *); String(const String &); … }; http://ecomputernotes.com

Assignment operator String::String(char * ptr){ if(ptr != NULL){ size = strlen(ptr); bufferPtr = new char[size+1]; strcpy(bufferPtr, ptr); } else{ bufferPtr = NULL; size = 0; } } http://ecomputernotes.com

Assignment operator String::String(const String & rhs){ size = rhs.size; if(rhs.size != 0){ bufferPtr = new char[size+1]; strcpy(bufferPtr, ptr); } else bufferPtr = NULL; } http://ecomputernotes.com

Assignment operator int main(){ String str1(“Hello"); String str2(“World”); str1 = str2; return 0; } Member wise copy assignment http://ecomputernotes.com

Assignment operator Result of str1 = str2 (memory leak) str1 Hello str2 World http://ecomputernotes.com

Assignment operator Modifying: class String{ … public: … void operator =(const String &); }; http://ecomputernotes.com

Assignment operator void String::operator = (const String & rhs){ size = rhs.size; if(rhs.size != 0){ delete [] bufferPtr; bufferPtr = new char[rhs.size+1]; strcpy(bufferPtr,rhs.bufferPtr); } else bufferPtr = NULL; }

Assignment operator int main(){ String str1(“ABC"); String str2(“DE”), str3(“FG”); str1 = str2; // Valid… str1 = str2 = str3; // Error… return 0; }

Assignment operator str1=str2=str3 is resolved as: str1.operator=(str2.operator= (str3)) Return type is void. Parameter can’t be void http://ecomputernotes.com