■ C++ 函数重载简介

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
重载声明是指一个与之前已经在该作用域内声明过的函数具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。
函数名相同，参数不同；

示例一：函数重载

#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;
}
会产生下列结果：
整数为: 5
浮点数为: 500.263
字符串为: Hello C++

■ C++ 运算符重载

您可以重定义或重载大部分 C++ 内置的运算符。
函数名是由关键字 operator 和其后要重载的运算符符号构成的。
重载运算符有一个返回类型和一个参数列表。

Box operator+(const Box&);     //声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象

■ 一元运算符重载

一元运算符只对一个操作数进行操作

示例一：

#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，类型为 BoxBox Box2;                // 声明 Box2，类型为 BoxBox Box3;                // 声明 Box3，类型为 Boxdouble 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;// 把两个对象相加，得到 Box3Box3 = Box1 + Box2;// Box3 的体积volume = Box3.getVolume();cout << "Volume of Box3 : " << volume <<endl;return 0;
}
它会产生下列结果：
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

示例二：一元减运算符，即负号（ - ）

#include <iostream>
using namespace std;class Distance
{private:int feet;             // 0 到无穷int inches;           // 0 到 12public:// 所需的构造函数Distance(){feet = 0;inches = 0;}Distance(int f, int i){feet = f;inches = i;}// 显示距离的方法void displayDistance(){cout << "F: " << feet << " I:" << inches <<endl;}// 重载负运算符（ - ）Distance operator- ()  {feet = -feet;inches = -inches;return Distance(feet, inches);}
};
int main()
{Distance D1(11, 10), D2(-5, 11);-D1;                     // 取相反数D1.displayDistance();    // 距离 D1-D2;                     // 取相反数D2.displayDistance();    // 距离 D2return 0;
}
它会产生下列结果：
F: -11 I:-10
F: 5 I:-11

■ 二元运算符重载 （+，-，*，/）

二元运算符需要两个参数（+，-，*,/）

示例一：

   // 重载 + 运算符，用于把两个 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;}
函数使用：
// 把两个对象相加，得到 Box3
Box3 = Box1 + Box2;

■ 关系运算符重载 （ < 、 > 、 <= 、 >= 、 == 等等）

C++ 语言支持各种关系运算符（ < 、 > 、 <= 、 >= 、 == 等等）

示例一：

#include <iostream>
using namespace std;class Distance
{private:int feet;             // 0 到无穷int inches;           // 0 到 12public:// 所需的构造函数Distance(){feet = 0;inches = 0;}Distance(int f, int i){feet = f;inches = i;}// 显示距离的方法void displayDistance(){cout << "F: " << feet << " I:" << inches <<endl;}// 重载负运算符（ - ）Distance operator- ()  {feet = -feet;inches = -inches;return Distance(feet, inches);}// 重载小于运算符（ < ）bool operator <(const Distance& d){if(feet < d.feet){return true;}if(feet == d.feet && inches < d.inches){return true;}return false;}
};使用：
int main()
{Distance D1(11, 10), D2(5, 11);if( D1 < D2 ){cout << "D1 is less than D2 " << endl;}else{cout << "D2 is less than D1 " << endl;}return 0;
}
它会产生下列结果：
D2 is less than D1

■ 输入/输出运算符重载（运算符 >> 运算符 << ）

C++ 能够使用流提取运算符 >> 和流插入运算符 << 来输入和输出内置的数据类型。
您可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。
示例一：

#include <iostream>
using namespace std;class Distance
{private:int feet;             // 0 到无穷int inches;           // 0 到 12public:// 所需的构造函数Distance(){feet = 0;inches = 0;}Distance(int f, int i){feet = f;inches = i;}friend ostream &operator<<( ostream &output, const Distance &D ){ output << "F : " << D.feet << " I : " << D.inches;return output;            }friend istream &operator>>( istream  &input, Distance &D ){ input >> D.feet >> D.inches;return input;            }
};
int main()
{Distance D1(11, 10), D2(5, 11), D3;cout << "Enter the value of object : " << endl;cin >> D3;cout << "First Distance : " << D1 << endl;cout << "Second Distance :" << D2 << endl;cout << "Third Distance :" << D3 << endl;return 0;
}它会产生下列结果：
$./a.out
Enter the value of object :
70
10
First Distance : F : 11 I : 10
Second Distance :F : 5 I : 11
Third Distance :F : 70 I : 10

■ 赋值运算符重载（ = ）

用于创建一个对象，比如拷贝构造函数。

示例一：

#include <iostream>
using namespace std; 
class Distance
{private:int feet;             // 0 到无穷int inches;           // 0 到 12public:// 所需的构造函数Distance(){feet = 0;inches = 0;}Distance(int f, int i){feet = f;inches = i;}void operator=(const Distance &D ){ feet = D.feet;inches = D.inches;}// 显示距离的方法void displayDistance(){cout << "F: " << feet <<  " I:" <<  inches << endl;}};
int main()
{Distance D1(11, 10), D2(5, 11);cout << "First Distance : "; D1.displayDistance();cout << "Second Distance :"; D2.displayDistance();// 使用赋值运算符D1 = D2;cout << "First Distance :"; D1.displayDistance();return 0;
}
它会产生下列结果：
First Distance : F: 11 I:10
Second Distance :F: 5 I:11
First Distance :F: 5 I:11

■ 函数调用运算符 () 重载

函数调用运算符 () 可以被重载用于类的对象。
当重载 () 时，您不是创造了一种新的调用函数的方式，相反地，这是创建一个可以传递任意数目参数的运算符函数。

示例一：

#include <iostream>
using namespace std;class Distance
{private:int feet;             // 0 到无穷int inches;           // 0 到 12public:// 所需的构造函数Distance(){feet = 0;inches = 0;}Distance(int f, int i){feet = f;inches = i;}// 重载函数调用运算符Distance operator()(int a, int b, int c){Distance D;// 进行随机计算D.feet = a + c + 10;D.inches = b + c + 100 ;return D;}// 显示距离的方法void displayDistance(){cout << "F: " << feet <<  " I:" <<  inches << endl;}      
};
int main()
{Distance D1(11, 10), D2;cout << "First Distance : "; D1.displayDistance();D2 = D1(10, 10, 10); // invoke operator()cout << "Second Distance :"; D2.displayDistance();return 0;
}
它会产生下列结果：
First Distance : F: 11 I:10
Second Distance :F: 30 I:120

■ 下标运算符 [] 重载

下标操作符 [] 通常用于访问数组元素。
重载该运算符用于增强操作 C++ 数组的功能。

示例一：

#include <iostream>
using namespace std;
const int SIZE = 10;class safearay
{private:int arr[SIZE];public:safearay() {register int i;for(i = 0; i < SIZE; i++){arr[i] = i;}}int& operator[](int i){if( i >= SIZE ){cout << "索引超过最大值" <<endl; // 返回第一个元素return arr[0];}return arr[i];}
};
int main()
{safearay A; cout << "A[2] 的值为 : " << A[2] <<endl;cout << "A[5] 的值为 : " << A[5]<<endl;cout << "A[12] 的值为 : " << A[12]<<endl;return 0;
}它会产生下列结果：
$ g++ -o test test.cpp
$ ./test 
A[2] 的值为 : 2
A[5] 的值为 : 5
A[12] 的值为 : 索引超过最大值
0

■ 类成员访问运算符 -> 重载

类成员访问运算符（ -> ）可以被重载，但它较为麻烦。
它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。
如果使用了 -> 运算符，返回类型必须是指针或者是类的对象。

运算符 -> 通常与指针引用运算符 * 结合使用，用于实现"智能指
示例一：

#include <iostream>
#include <vector>
using namespace std;// 假设一个实际的类
class Obj {static int i, j;
public:void f() const { cout << i++ << endl; }void g() const { cout << j++ << endl; }
};// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;// 为上面的类实现一个容器
class ObjContainer {vector<Obj*> a;
public:void add(Obj* obj){ a.push_back(obj);  // 调用向量的标准方法}friend class SmartPointer;
};// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {ObjContainer oc;int index;
public:SmartPointer(ObjContainer& objc){ oc = objc;index = 0;}// 返回值表示列表结束bool operator++() // 前缀版本{ if(index >= oc.a.size() - 1) return false;if(oc.a[++index] == 0) return false;return true;}bool operator++(int) // 后缀版本{ return operator++();}// 重载运算符 ->Obj* operator->() const {if(!oc.a[index]){cout << "Zero value";return (Obj*)0;}return oc.a[index];}
};int main() {const int sz = 10;Obj o[sz];ObjContainer oc;for(int i = 0; i < sz; i++){oc.add(&o[i]);}SmartPointer sp(oc); // 创建一个迭代器do {sp->f(); // 智能指针调用sp->g();} while(sp++);return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：10
12
11
13
12
14
13
15
14
16
15
17
16
18
17
19
18
20
19
21