Cplusplus 简明教程
C++ Overloading (Operator and Function)
C++ 允许您为同一范围内的名称或运算符指定多个定义，分别称为 function 和 operator 。
C++ allows you to specify more than one definition for a function name or an operator in the same scope, which is called function overloading and operator overloading respectively.
重载声明是声明的声明与同一范围内的先前声明的声明名称相同，但这两个声明具有不同的参数，显然具有不同的定义（实现）。
An overloaded declaration is a declaration that is declared with the same name as a previously declared declaration in the same scope, except that both declarations have different arguments and obviously different definition (implementation).
当您调用重载的 function 或 operator 时，编译器会通过比较您用来调用函数或运算符的参数类型和定义中指定的参数类型来确定最合适的定义来使用。选择最合适的重载函数或运算符的过程称为 overload resolution 。
When you call an overloaded function or operator, the compiler determines the most appropriate definition to use, by comparing the argument types you have used to call the function or operator with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.
Function Overloading in C++
可以在相同范围内为同一函数名称设置多个定义。函数的定义通过参数列表中的类型和/或参数的数量相互区分。您无法重载仅通过返回类型不同的函数声明。
You can have multiple definitions for the same function name in the same scope. The definition of the function must differ from each other by the types and/or the number of arguments in the argument list. You cannot overload function declarations that differ only by return type.
以下是使用相同的函数 print() 用于打印不同数据类型 −的示例。
Following is the example where same function print() is being used to print 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 produces the following result −
Printing int: 5
Printing float: 500.263
Printing character: Hello C++Operators Overloading in C++
您可以重新定义或重载 C++ 中提供的大部分内置运算符。因此，程序员也可以使用带有用户定义类型的运算符。
You can redefine or overload most of the built-in operators available in C++. Thus, a programmer can use operators with user-defined types as well.
重载运算符是有特殊名称的函数：“operator”关键字后跟正在定义的运算符符号。像任何其他函数一样，重载运算符都有一个返回类型和一个参数列表。
Overloaded operators are functions with special names: the keyword "operator" followed by the symbol for the operator being defined. Like any other function, an overloaded operator has a return type and a parameter list.
Box operator+(const Box&);声明可以用 add 的加法运算符两个 Box 对象，并返回最终 Box 对象。大多数重载运算符可以定义为普通非成员函数或类成员函数。如果我们将上述函数定义为类的非成员函数，那么我们将必须为每个操作数传递两个参数，如下所示 −
declares the addition operator that can be used to add two Box objects and returns final Box object. Most overloaded operators may be defined as ordinary non-member functions or as class member functions. In case we define above function as non-member function of a class then we would have to pass two arguments for each operand as follows −
Box operator+(const Box&, const Box&);以下是使用成员函数显示运算符重载概念的示例。此处将对象作为参数传递，其属性将使用此对象进行访问，可以 this 使用运算符访问将调用此运算符的对象，如下所述 −
Following is the example to show the concept of operator over loading using a member function. Here an object is passed as an argument whose properties will be accessed using this object, the object which will call this operator can be accessed using this operator as explained 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;
}
// Overload + operator to add two Box objects.
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; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
// Main function for the program
int main() {
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
Box Box3; // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume <<endl;
// volume of box 2
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume <<endl;
// Add two object as follows:
Box3 = Box1 + Box2;
// volume of box 3
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 : 5400Overloadable/Non-overloadableOperators
以下是可重载的运算符列表 −
Following is the list of operators which can be overloaded −
+ |
- |
* |
/ |
% |
^ |
& |
~ |
! |
, |
||
= |
< |
> |
⇐ |
>= |
++ |
— |
<< |
>> |
== |
!= |
&& |
+= |
-= |
/= |
|||
%= |
^= |
&= |
= |
*= |
|
<⇐ |
>>= |
[] |
() |
→ |
→* |
以下是无法重载的运算符列表 −
Following is the list of operators, which can not be overloaded −
:: |
.* |
. |
?: |