Introduction

Operator overloading is one of the best features of C++. By overloading operators, we can give additional meaning to operators like +,-,*,<=,>=, etc. which by default are supposed to work only on standard data types like int, float, etc.
The operators that cannot be overloaded are ., ::, ? and : .
Here, we created a simple class, whose name is xy example for operator overloading. We created two int variables, x,y, to test all operations of operator overloading features in C++.
  1. #include<iostream.h>
  2. #include<conio.h>
  3. class xy
  4. {
  5. private:
  6. int x,y;
  7. public:
  8. // ======constructors=========
  9. xy()
  10. { x=y=0; }
  11. xy(int i,int j)
  12. {x=i;y=j;}
  13. xy(xy &z)
  14. {x=z.x;y=z.y;}
  15. // ====== unary operators ========
  16. xy operator-();
  17. xy operator++();
  18. xy operator--();
  19. xy operator++(int);
  20. xy operator--(int);
  21. //======= binary operators ========
  22. xy operator+(xy &);
  23. xy operator-(xy &);
  24. xy operator*(xy &);
  25. xy operator/(xy &);
  26. xy operator%(xy &);
  27. xy operator=(xy &);
  28. xy operator+=(xy &);
  29. xy operator-=(xy &);
  30. xy operator*=(xy &);
  31. xy operator/=(xy &);
  32. xy operator%=(xy &);
  33. // =======comparison or logical operators============
  34. int operator<(xy &);
  35. int operator>(xy &);
  36. int operator==(xy &);
  37. int operator!=(xy &);
  38. int operator<=(xy &);
  39. int operator>=(xy &);
  40. //========= inseration and extraction operators ==========
  41. friend ostream&operator<<(ostream&, xy&);
  42. friend istream&operator>>(istream&, xy&);
  43. };
Next, we created a body of all functions and called a function in the functions of a C++ program.
  1. //Function operator-() for return absolute value.
  3. xy xy::operator-()
  4. {
  5. if(x<0){x*=-1;}
  6. if(y<0){y*=-1;}
  7. return *this;
  8. }
  10. //Function of unary operators.
  12. xy xy::operator++()
  13. {
  14. ++x;++y;
  15. return *this;
  16. }
  17. xy xy::operator--()
  18. {
  19. --x;--y;
  20. return *this;
  21. }
  22. xy xy::operator++(int)
  23. {
  24. x++;y++;
  25. return *this;
  26. }
  27. xy xy::operator--(int)
  28. {
  29. x--;y--;
  30. return *this;
  31. }
  33. //Function of binary operators.
  35. xy xy::operator+(xy &z)
  36. {
  37. xy t;
  38. t.x=x+z.x;
  39. t.y=y+z.y;
  40. return t;
  41. }
  42. xy xy::operator-(xy &z)
  43. {
  44. xy t;
  45. t.x=x-z.x;
  46. t.y=y-z.y;
  47. return t;
  48. }
  49. xy xy::operator*(xy &z)
  50. {
  51. xy t;
  52. t.x=x*z.x;
  53. t.y=y*z.y;
  54. return t;
  55. }
  56. xy xy::operator=(xy &z)
  57. {
  58. x=z.x;y=z.y;
  59. return *this;
  60. }
  61. xy xy::operator/(xy &z)
  62. {
  63. xy t;
  64. t.x=x/z.x;
  65. t.y=y/z.y;
  66. return t;
  67. }
  68. xy xy::operator%(xy &z)
  69. {
  70. xy t;
  71. t.x=x%z.x;
  72. t.y=y%z.y;
  73. return t;
  74. }
  75. xy xy::operator+=(xy &z)
  76. {
  77. xy t;
  78. t.x=x+z.x;
  79. t.y=y+z.y;
  80. return t;
  81. }
  82. xy xy::operator-=(xy &z)
  83. {
  84. xy t;
  85. t.x=x-z.x;
  86. t.y=y-z.y;
  87. return t;
  88. }
  89. xy xy::operator*=(xy &z)
  90. {
  91. xy t;
  92. t.x=x*z.x;
  93. t.y=y*z.y;
  94. return t;
  95. }
  96. xy xy::operator/=(xy &z)
  97. {
  98. xy t;
  99. t.x=x/z.x;
  100. t.y=y/z.y;
  101. return t;
  102. }
  103. xy xy::operator%=(xy &z)
  104. {
  105. xy t;
  106. t.x=x%z.x;
  107. t.y=y%z.y;
  108. return t;
  109. }
  111. //Function of insertion(>>) & extraction(<<) operators.
  113. ostream&operator<<(ostream &o, xy &z)
  114. {
  115. o<<endl<<"(x: "<<z.x<<",y: "<<z.y<<")";
  116. return o;
  117. }
  118. istream&operator>>(istream &i, xy &z)
  119. {
  120. cout<<endl<<"Enter X & Y: ";
  121. i>>z.x>>z.y;
  122. return i;
  123. }
  125. //main program to call some overloaded operators.
  127. void main()
  128. {
  129. clrscr();
  130. xy a,b(10,20),c;
  131. cin>>a;
  132. cout<<a<<b;
  133. cout<<endl<<"a+b:";
  134. c=a+b;
  135. cout<<c;
  136. cout<<endl<<"a-b:";
  137. c=a-b;
  138. cout<<c;
  139. cout<<endl<<"a*b:";
  140. c=a*b;
  141. cout<<c;
  142. cout<<endl<<"a/b:";
  143. c=a/b;
  144. cout<<c;
  145. cout<<endl<<"a%b:";
  146. c=a%b;
  147. cout<<c;
  148. cout<<endl<<"c+=b:";
  149. c=c+=b;
  150. cout<<c;
  151. getch();
  152. }
Output
The calling function internal layout is c=a.operator+(b); but C++ provided user-friendly features operator overloading, so our calling layout is c=a+b like normal default data types operations. I hope operator overloading will be helpful for students and beginner to understand basic fundamentals of object-oriented programming.