1. Object-Oriented Programming (OOP) Lecture No. 18

2. Modifying: class String{ … public: void operator =(const String &); };
Assignment operator
Modifying:
class String{ …
public:
void operator =(const String &); };

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

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

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

6. Assignment operator
Solution: modify the operator = function as follows:
class String{ …
public:
String & operator = (const String &); };

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

8. Assignment operator void main(){ String str1(“AB");
String str2(“CD”), str3(“EF”);
str1 = str2;
str1 = str2 = str3; // Now valid… }

9. str1=str2=str3 is resolved as: str1.operator=(str2.operator= (str3))
Assignment operator
str1=str2=str3 is resolved as:
str1.operator=(str2.operator= (str3))
Return type is String .

10. Assignment operator int main(){ String str1("Fakhir");
// Self Assignment problem…
str1 = str1;
return 0; }

11. Assignment operator str1 Result of str1 = str1 ??? Fakhir …
// size = rhs.size;
// delete [] bufferPtr;
???
Fakhir
str1

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

13. Assignment operator int main(){ String str1("Fakhir"); str1 = str1;
Now self-assignment is properly handled:
int main(){
String str1("Fakhir");
str1 = str1;
return 0; }

14. Assignment operator
Solution: modify the operator= function as follows:
class String{ …
public:
const String & operator=
(const String &); };

15. Assignment operator int main(){ String s1(“ABC”), s2(“DEF”),
s3(“GHI”);
// Error…
(s1 = s2) = s3;
return 0; }

16. Assignment operator But we can do the following with primitive types:
int main(){
int a, b, c;
(a = b) = c;
return 0; }

17. Other Binary operators
Overloading += operator:
class Complex{
double real, img;
public:
Complex & operator+=(const Complex & rhs);
Complex & operator+=(count double & rhs);
... };

18. Other Binary operators
Complex & Complex::operator += (const Complex & rhs){
real = real + rhs.real;
img = img + rhs.img;
return * this; }

19. Other Binary operators
Complex & Complex::operator += (const double & rhs){
real = real + rhs;
return * this; }

20. Other Binary operators
int main(){
Complex c1, c2, c3;
c1 += c2;
c3 += 0.087;
return 0; }

21. Operator overloading Friend functions minimize encapsulation
This can result in:
Data vulnerability
Programming bugs
Tough debugging
Hence, use of friend functions must be limited

22. Operator overloading
The + operator can be defined as a non-member, non-friend function:
Complex operator + (const Complex & a, const Complex & b){
Complex t = a;
return t += b }

23. Operator overloading
Complex operator + (const double & a, const Complex & b){
Complex t = b;
return t += a; }

24. Operator overloading
Complex operator + (const Complex & a, const double & b){
Complex t = a;
return t += b; }

25. Other Binary operators
The operators
-=, /=, *=, |=, %=, &=, ^=, <<=, >>=, !=
can be overloaded in a very similar fashion