C++ overloaded operators and overloaded functions

Function overloading in C++

In the same scope, you can declare several functions of the same name with similar functions, but the formal parameters of these functions with the same name (referring to the number, type or order of parameters) must different. You cannot overload a function simply by differing in return type.

In the following example, the function of the same name print() is used to output different data types:

#include <iostream>
using namespace std;
 
class printData 
{
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }

      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }

      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void)
{
   printData pd;
 
   // Call print to print integer
   pd.print(5);
   // Call print to print float
   pd.print(500.263);
   // Call print to print character
   pd.print("Hello C++");
 
   return 0;
}

When the above code is compiled and executed, it will Produces the following results:

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Operator Overloading in C++

You can redefine or overload most of the C++ built-in operators. This allows you to use custom types of operators.

The overloaded operator is a function with a special name. The function name is composed of the keyword operator and the operator symbol to be overloaded. Like other functions, overloaded operators have a return type and a parameter list.

Box operator+(const Box&);

Declares that the addition operator is used to add two Box objects and return the final Box object. Most overloaded operators can be defined as ordinary non-member functions or as class member functions. If we define the above function as a non-member function of the class, then we need to pass two parameters for each operation, as shown below:

Box operator+(const Box&, const Box&);

The following example demonstrates the concept of operator overloading using member functions. Here, the object is passed as parameter and the properties of the object are accessed using this operator as shown below:

#include <iostream>
using namespace std;

class Box
{
   public:

      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }

      void setBreadth( double bre )
      {
          breadth = bre;
      }

      void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;

   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

When the above code is compiled and executed, it produces the following Result:

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Overloadable operators/non-overloadable operators

The following is a list of overloadable operators:

##|=*=<<=>>=[]()##->The following is a list of operators that cannot be overloaded:

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
->*	new	new []	delete	delete []

::

Operator overloading examples

The following provides examples of various operator overloadings to help you better understand the concept of overloading.

.*

.

?:

Serial number	Operators and examples
1	Unary operator overloading
2	Binary operator overloading
3	Relational operator overloading
4	Input/output operator overloading
5	++ and -- operator overloading
6	Assignment operator overloading
7	Function call operator () overloading
8	Subscript operator[] overload
9	Class member access operator-> Overload