C++语言-04-重载

相关概念

重载

在同一作用域中为某个函数和运算符指定多个定义，分别成为函数重载和运算符重载

重载声明

与之前已经在作用域内声明过的函数或方法具有相同名称的声明，参数列表和定义不同

重载决策

调用一个重载函数或重载运算符时，编译器需要比较调用函数时的参数类型与定义时的参数类型，来选择最合适的重载函数和重载运算符，这个过程称为重载决策

函数重载

规则

函数名相同

参数列表不同

与返回类型无关

示例

// 两个整数相加
int sum(int a, int b) {
cout << "sum of two int number: " << a + b << endl;
return a + b;
}
// 两个双精度小数相加
double sum(double a, double b) {
cout << "sum of two double number: " << a + b << endl;
return a + b;
}
int main(int argc, const char * argv[]) {
sum(1, 2); // 两个整数相加
sum(1.0, 2.0); // 两个双精度小数相加
sum(1, 2.0); //Call to 'sum' is ambiguous
return 0;
}

运算符重载

运算符的实质

带有特殊名称的函数

不可重载的运算符

运算符	含义
::	作用于解析运算符
.*	成员对象选择运算符
.	以对象方式访问成员运算符
?:	条件判断运算符

示例

一元运算符++

具有前缀形式和后缀形式，前缀形式的运算符重载函数没有参数，后缀形式的运算符重载函数具有参数

// 创建一个Apple的类
class AppleBasket {
private:
double appleWeight; // 苹果的重量
double priceOfPerKg; // 每千克苹果的价格
double totalPrices; // 苹果的总价格
public:
// set、get方法
void setAppleWeight(double weight) {
appleWeight = weight;
}
double getAppleWeight() {
return appleWeight;
}
void setPriceOfPerKg(double price) {
priceOfPerKg = price;
}
double getPriceOfPerKg() {
return priceOfPerKg;
}
double getTotalPrices() {
if (totalPrices == 0) { // 不打折
totalPrices = appleWeight * priceOfPerKg;
}
return totalPrices;
}
// 构造方法
AppleBasket() {
appleWeight = 0;
priceOfPerKg = 0;
}
AppleBasket(double priceOfPer, double weight) {
appleWeight = weight;
priceOfPerKg = priceOfPer;
}
// 运算符重载
/** 一筐苹果的重量自增 */
AppleBasket operator++() { // 前缀
AppleBasket apple;
apple.appleWeight = ++this->appleWeight;
apple.priceOfPerKg = this->priceOfPerKg;
return apple;
}
AppleBasket operator++(int) { // 后缀，参数必须是int
AppleBasket apple = *this;
this->appleWeight++;
return apple;
}
};

二元运算符+

/** 两筐苹果的重量相加 */
AppleBasket operator+(AppleBasket other) {
AppleBasket apple;
apple.appleWeight = this->appleWeight + other.appleWeight;
apple.priceOfPerKg = this->priceOfPerKg;
return apple;
}

赋值运算符=

通常用来创建一个新的对象

/** 赋值运算符 */
void operator=(AppleBasket other) {
appleWeight = other.appleWeight;
priceOfPerKg = other.priceOfPerKg;
}

逻辑运算符<

/** 比较this框苹果的重量是否小于other框苹果的质量 */
bool operator<(AppleBasket other) {
if (this->appleWeight < other.appleWeight) {
return true;
} else {
return false;
}
}

函数调用运算符

不是创建一种新的函数调用方式

实际上是创建了一个可以传递任意数目参数的运算符函数

/** 函数调用运算符 */
AppleBasket operator()(double w, double p, double totalP) {
AppleBasket apple;
apple.appleWeight = w;
apple.priceOfPerKg = p;
apple.totalPrices = totalP;
return apple;
}

类成员访问运算符->

通常用于为一个类赋予“指针”行为

重载的运算符函数，必须是一个成员函数，且返回类型必须是指针或者类的对象

运算符->通常与指针引用运算符*结合使用，用来实现“智能指针”的功能，通过智能指针访问对象，可以执行与普通指针不同的任务

// Apple类的容器
class AppleBasketContainer {
private:
vector<AppleBasket *> container;
public:
void add(AppleBasket *apple) {
container.push_back(apple);
}
// 友元类
friend class SmartPointer;
};
//AppleBasketContainer类的友元类
class SmartPointer {
private:
AppleBasketContainer appleContainer;
int index;
public:
// 构造函数
SmartPointer(AppleBasketContainer& ac) {
appleContainer = ac;
index = 0;
}
// 运算符重载
/** 返回值表示列表结束 */
bool operator++() { // 前缀版本
if (index > appleContainer.container.size()) return false;
if (appleContainer.container[++index] == 0) return false;
return true;
}
bool operator++ (int) { // 后缀版本
return operator++();
}
/** 重载运算符 -> */
Apple* operator->() {
if (!appleContainer.container[index]) {
cout << "Zero value!";
return (Apple*)0;
}
return appleContainer.container[index];
}
};

输入/输出运算符

通常将运算符重载函数定义为友元函数，使得在不创建对象的情况下调用函数

// 输入运算符
friend istream &operator>>(istream &input, AppleBasket &apple) {
cout << "请输入每kg苹果的价钱：";
input >> apple.priceOfPerKg;
cout << "请输入苹果的总重量：";
input >> apple.appleWeight;
apple.totalPrices = apple.appleWeight * apple.priceOfPerKg;
return input;
}
// 输出运算符
friend ostream &operator<<(ostream &output, const AppleBasket &apple) {
output << "每kg苹果的价格为：" << apple.priceOfPerKg << endl;
output << "苹果的总重量为：" << apple.appleWeight << endl;
output << "苹果的总价为：" << apple.totalPrices << endl;
return output;
}

下表运算符[]

通常用来增强数组的功能，如：数组越界检查

// 每个班级中最多的学生个数
const int MaxStudentCountOfPerTeacher = 45;
class Student {
private:
int studentId;
int age;
public:
// set，get方法
void setAge(int a) {
age = a;
}
int getAge() {
return age;
}
// studentId通常是自增的，不暴露set方法
int getStudentId() {
return studentId;
}
// 设置Teacher为Student的友元类，使Teacher可以访问Student的私有成员
friend class Teacher;
};
class Teacher {
private:
Student students[MaxStudentCountOfPerTeacher];
public:
// 构造函数
Teacher() {
for (int i = 0; i < 45; i++) {
students[i].studentId = i + 1;
}
}
// 运算符重载(数组越界检查)
Student operator[](int i) {
if (i >= MaxStudentCountOfPerTeacher) {
cout << "Index out of bounds" << endl;
return students[0];
}
return students[i];
}
};

重载运算符的简单使用

// 重载运算符的使用示例
int main(int argc, const char * argv[]) {
const int size = 10;
AppleBasket apples[size];
AppleContainer appleContainer;
// 初始化apples与appleContainer
for (int i = 0; i < size; i++) {
apples[i].setAppleWeight(i);
apples[i].setPriceOfPerKg(8.8);
appleContainer.add(&apples[i]);
}
// 创建一个迭代器
SmartPointer smartPointer(appleContainer);
do {
double totalPrice = smartPointer->getTotalPrices();
cout << "苹果的总价格为：" << totalPrice << endl;
} while (smartPointer++);
// 自增运算符++(前缀)
cout << "第一筐苹果的总价格为：" << (++apples[0]).getTotalPrices() << endl;
// 自增运算符++(后缀)
cout << "第二筐苹果的总价格为：" << (apples[0]++).getTotalPrices() << endl;
// 运算符+
cout << "前两筐苹果的总价为：" << (apples[0] + apples[1]).getTotalPrices() << endl;
// 逻辑运算符<
if (apples[0] < apples[1]) {
cout << "第一筐苹果的重量小于第二筐苹果的重量" << endl;
} else {
cout << "第一筐苹果的重量大于等于第二筐苹果的重量" << endl;
}
// 赋值运算符=
AppleBasket apple = apples[2];
cout << "第三筐苹果的重量为：" << apple.getAppleWeight() << endl;
// 函数调用运算符()
cout << "3kg苹果打折后的价格为：" << apple(3, 8.8, 20.0).getTotalPrices() << endl;
// 输入输出运算符<<，>>
cin >> apple;
cout << apple;
// 下标运算符[]
Teacher teacher;
Student student;
student = teacher[MaxStudentCountOfPerTeacher - 1];
cout << "最后一个学生的学号为：" << student.getStudentId() << endl;
student = teacher[MaxStudentCountOfPerTeacher];
cout << student.getStudentId() << endl;
return 0;
}