C++ 重载（二）

在上一篇文章中，我们定义了一个Time时间类，完成了对‘+’运算符的重载，后面可以通过 对象1+对象2 的形式来计算总共花费的时间。这样后面有多个Time类的时间对象直接通过‘+’就可以完成时间相加了，比如下面：

1.使用重载‘+’成员函数实现多个Time类对象相加

#include<iostream>
#include"Time.h"

using namespace std;

int main() {
	Time t1(3,20);
	Time t2(2, 40);
	Time t3(5, 55);
	Time t4;

	t1.Show();
	t2.Show();
	t3.Show();

	t4 = t1 + t2 + t3;
    //重载之后，实现多个对象相加，这样是不是很简洁、方便

	t4.Show();//三个时间相加完后的结果
	
	return 0;
}

2.对‘-’进行重载，实现两个对象时间相减

接下来实现‘-’号重载，在Time.h头文件增加对‘-’重载成员函数的声明：

Time operator-(const Time& t) const;

然后，在Time.cpp文件中实现该成员函数：

Time Time::operator-(const Time& t) const {
	Time diff;
	int tot1, tot2;
    //定义两个整数类型用来统计一个多少分钟
	tot1 = this->hours * 60 + this->minutes;
	tot2 = t.hours * 60 + t.minutes;
    //之后在进行时间格式转换
	diff.minutes = (tot1 - tot2) % 60;
	diff.hours = (tot1 - tot2) / 60;
    //最后返回结果对象
	return diff;
}

最后在test.cpp上加上

#include<iostream>
#include"Time.h"

using namespace std;

int main() {
	Time t1(3,20);
	Time t2(2, 40);
	Time t3(5, 55);
	Time t4;
	//调用了不同的构造函数进行了初始化，这就是重载的用处！
	//这就好比人，每个人都是一个对象，每个人都是独一无二的,扯多了哈哈

	t1.Show();
	t2.Show();
	t3.Show();

	t4 = t1 + t2 + t3;
	//t1是按引用传值，这样比按值传递速度快、节约内存；
	//注意这个返回值是一个对象，所以创建一个对象t3来接受

	t4.Show();//两个时间相加完后的结果
	
	Time t5;
	t5 = t3 - t2;
	t5.Show();

	return 0;
}

注意对象的顺序，t3在t2前面等价于t3.operator-(t2),所以调用函数时，this指针指向的t3哈，这里要注意一下！ 不废话了，看结果：

3. 对‘*’进行重载，实现将hour mintues成员数据倍乘

先对Time.h头文件增加对‘*’重载成员函数的声明：

Time operator*(double e) const;

然后在Time.cpp文件中实现该成员函数：

Time Time::operator*(double e) const {
	Time mul;
	long tot;
	tot = this->minutes * e + this->hours * 60 * e;
	mul.minutes = tot % 60;
	mul.hours = tot / 60;
	return mul;
}

最后在测试文件中调用：

#include<iostream>
#include"Time.h"

using namespace std;

int main() {
	Time t1(3,20);
	Time t2(2, 40);
	Time t3(5, 55);
	Time t4;
	//调用了不同的构造函数进行了初始化，这就是重载的用处！
	//这就好比人，每个人都是一个对象，每个人都是独一无二的,扯多了哈哈

	t1.Show();
	t2.Show();
	t3.Show();

	t4 = t1 + t2 + t3;
	//t1是按引用传值，这样比按值传递速度快、节约内存；
	//注意这个返回值是一个对象，所以创建一个对象t3来接受

	t4.Show();//两个时间相加完后的结果
	
	Time t5;
	t5 = t3 - t2;
	t5.Show();

	Time t6;
	t6 = t1 * 2.0;
	t6.Show();

	return 0;
}

是不是比较简单，其实+、-、*、/、格式都是一样的，主要看你完成什么事情。

4.对自增运算符++、--进行重载

下面我对 单目运算符++、--进行重载，这个也挺好理解的：

我重新给个背景，比如说上班日结工资这件事：你每上一天班，给你一天的工资100，但是你如果旷工一天扣100，这样我们定义一个员工类，通过重载自增自减运算符来实现：

首先在头文件Employee.h中声明成员函数和成员数据：

#pragma once
#include<iostream>

class Employee {
public:
	Employee();//默认无参构造函数
	Employee(int a, int b);//构造函数重载
	Employee operator++();//前置自增
	Employee operator--();/前置自减
	Employee operator++(int);//后置自增
	Employee operator--(int);//后置自减
	void display();

private:
	int emp_number;//员工编号
	int wage;//员工日结工资
};

这里有一点，是前置和后置的区别，后置添加了一个int参数进行区别，我也不知道为什么这样做，但是在调用的时候编译器就自动识别了，目前还没理解（先打个问号？？？）

接下来看一下Employ.cpp文件中对头文件接口进行实现：

#include"Employee.h"

using namespace std;

Employee::Employee() {
	this->emp_number = 0;
	this->wage = 0;
}

Employee::Employee(int a, int b) {
	this->emp_number = a;
	this->wage = b;
}

Employee Employee::operator++(){
	Employee t;
	t.emp_number = this->emp_number;
	t.wage = ++this->wage;
	return t;
}

Employee Employee::operator--() {
	Employee s;
	s.emp_number = this->emp_number;
	s.wage = --this->wage;
	return s;
}

Employee Employee::operator++(int) {
	Employee t;
	t.emp_number = this->emp_number;
	t.wage = this->wage++;
	return t;
}

Employee Employee::operator--(int) {
	Employee s;
	s.emp_number = this->emp_number;
	s.wage = this->wage--;
	return s;
}
void Employee::display() {
	cout << "员工编号为：" << this->emp_number << "你的日结工资为：" << this->wage << endl;
}

测试一下：

#include"Employee.h"

int main() {
	Employee e1(1, 0);
	Employee e2(2, 1);
	Employee e3(3, 2);

	//e1上一天班，日结一天，工资加1，单位均是百元
	//e2 e3 两人旷工一天，工资减1
	Employee e4, e5, e6;

	e4 = ++e1;
	e4.display();

	e5 = --e2;
	e5.display();

	e6 = --e3;
	e6.display();


	return 0;
}

 这是对前置自增自减运算符重载测试，下面对后置自增自减进行测试：

#include"Employee.h"

int main() {
	Employee e1(1, 0);
	Employee e2(2, 1);
	Employee e3(3, 2);

	//e1上一天班，日结一天，工资加1，单位均是百元
	//e2 e3 两人旷工一天，工资减1
	Employee e4, e5, e6;

	e4 = e1++;
	e1.display();
	e4.display();

	e5 = e2--;
	e2.display();
	e5.display();

	e6 = e3--;
	e3.display();
	e6.display();


	return 0;
}

 发工资这个背景可能有点牵强，不过大概就是这么个意思，主要是学会对++、--运算符的重载就行了，哈哈。

关于对左移运算符<<的重载我下一篇文章再写，多看书和视频、多敲代码、多思考、多总结，有什么不对的地方欢迎大家批评指正，继续加油！！！