Latest web development tutorials

C ++ function overloading and operator overloading

C ++ allows one of thefunctions and operatorsin the same scope to specify more than one definition, it is calledfunction overloadingandoperator overloading.

Overloaded statement is one that has been declared in this scope before a function or method declarations have the same name, but their list of parameters and definitions (realization) are not the same.

When you call anoverloaded function or an overloaded operator,the compiler through the parameter type you are using, the type and definition of parameters are compared to determine the choice of the most appropriate definition. Select the most appropriate overloaded function or operator overloading process, calledoverload resolution.

In C ++ function overloading

In the same scope, you can declare several functions similar function with the same name, but these formal parameters (the number refers to the parameter type or sequentially) function with the same name must be different. You can not merely by returning to the different types of overloaded functions.

The following examples, the same name as the functionprint () is used to output different data types:

#include <iostream>
using namespace std;
class printData 
      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
   // Call print to print float
   // Call print to print character
   pd.print("Hello C++");
   return 0;

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

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

In C ++ operator overloading

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

The operator is overloaded with special function name, the function name is followed by the key operator and the operator to override the symbols. And other functions, overloaded operators have a return type and parameter list.

Box operator+(const Box&);

Statement of the addition operator for two Box objects are added, the final return of Box objects. Most overloaded operators can be defined as normal or non-member functions are defined as class member functions. If we define the above function as a non-member function classes, then we need to pass two parameters for each operation, as follows:

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

The following example demonstrates the member function operator overloading concept. Here, the object passed as a parameter, properties of an object usingthis operator be accessed as follows:

#include <iostream>
using namespace std;

class Box

      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;
      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 详述
   // Box2 详述
   // 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 results:

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

Overloaded operators can / can not be overloaded operators

The following is a list of operators can be overloaded:

->->*newnew []deletedelete []

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


Examples of operator overloading

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

1 一元运算符重载
2 二元运算符重载
3 关系运算符重载
4 输入/输出运算符重载
5 ++ 和 -- 运算符重载
6 赋值运算符重载
7 函数调用运算符 () 重载
8 下标运算符 [] 重载
9 类成员访问运算符 -> 重载