May 11, 2021 C++
1. Overload operators and overload functions in C+
2. The function overload in C+
3. The operators in C+ are overloaded
A function and operator in the same scope are allowed to specify multiple definitions, called function overloading and operator overloading, respectively.
Overloaded declarations are declarations that have the same name as a function or method that has previously been declared within the scope, but whose argument list and definition (implementation) are not the same.
When you call an overloaded function or overload operator, the compiler decides which definition is most appropriate by comparing the type of argument you are using with the type of argument in the definition. The process of selecting the most appropriate overload function or overload operator is called overloading decisions.
Within the same scope, you can declare several functions with similar functions of the same name, but the formal parameters of those functions of the same name (referring to the number, type, or order of arguments) must be different. You cannot overload a function just by returning a different 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 produces the following results:
Printing int: 5
Printing float: 500.263
Printing character: Hello C++
You can redefine or overload most of the operators that are built into C+. This allows you to use operators of custom types.
Overloaded operators are functions with special names, which are made up of the keyword operator and the operator symbols that are subsequently overloaded. Like other functions, overload operators have a return type and a list of arguments.
Box operator+(const Box&);
The declaration addition operator is used to add up two Box objects and return the final Box object. M ost overloaded operators can be defined as normal non-member functions or as class member functions. If we define the above function as a non-member function of the class, we need to pass two arguments for each operation, as follows:
Box operator+(const Box&, const Box&);
The following example uses member functions to demonstrate the concept of operator overloading. Here, the object is passed as an argument, and the object's properties are accessed using the this operator, as follows:
#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 results:
Volume of Box1 : 210 Volume of Box2 : 1560 Volume of Box3 : 5400
Here is a list of overloadable operators:
+ | - | * | / | % | ^ |
& | | | ~ | ! | , | = |
< | > | <= | >= | ++ | -- |
<< | >> | == | != | && | || |
+= | -= | /= | %= | ^= | &= |
|= | *= | <<= | >>= | [] | () |
-> | ->* | new | new [] | delete | delete [] |
Here is a list of non-overloadable operators:
:: | .* | . | ?: |
Examples of operator overloading are provided below to help you better understand the concept of overloading.