C++ object-oriented: C++ overloaded operators and overloaded functions

C++ allows multiple definitions of a function and operator in the same scope to be specified, which are called function overloading and operator overloading respectively .

An overloaded declaration refers to a declaration with the same name as a function or method that has been declared in the scope before, but their parameter list and definition (implementation) are different.

When you call an overloaded function or overloaded operator , the compiler compares the parameter type you are using with the parameter type in the definition and decides to choose the most appropriate definition. The process of selecting the most appropriate overloaded function or overloaded operator is called overload decision-making .

 

Function overloading in C++

Within the same scope, you can declare several functions with the same name with similar functions, but the formal parameters (referring to the number, type or order of the parameters) of these functions with the same name must be different. You can't overload a function just by the difference in return type.

C/C++ learning skirt [7, 12, 2, 84, 705], whether you are a novice or an advanced person, whether you want to change careers or want to enter a career, you can come to understand and learn together! There are development tools in the skirt, a lot of dry goods and technical information to share!

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

#include <iostream>
using namespace std;


class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }


      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }


      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};


int main(void)
{
   printData pd;


   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);


   return 0;
}

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

 

 

 

Operator overloading in C++

You can redefine or overload most C++ built-in operators. In this way, you can use custom types of operators.

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

Boxoperator+(constBox&);

Declare 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:

Boxoperator+(constBox&,constBox&);

The following example uses member functions to demonstrate the concept of operator overloading. Here, the object is passed as a parameter, and the properties of the object  are accessed using the  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 will produce the following results:

 

Overloadable operator/non-overloadable operator

The following is a list of operators that can be overloaded:

 

The following is a list of operators that cannot be overloaded:

• . : Member access operator
• .* ,  ->* : member pointer access operator
• ::: Domain operator
• sizeof : length operator
• ?:: Conditional operator
• # : preprocessing symbol

Operator overloading example

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