学习目标
在c++对象的学习中，我们会使用到运算符重载，接下来大家一起学习一下吧！
学习内容
运算符重载：
operator overloading运算符重载是一种形式的C++多态
即对已有运算符进行重新定义，赋予新的功能，使其适配不同的类型。
形式：operator op(对象参数）
💖总结（建议仔细阅读！！！）：
1、一元运算符：++ – a-- ++a-- 二元运算符：a+b
2、成员运算符函数： 一元是没有参数
二元只有一个参数：operator+(Time& t)
3、全局运算符函数： 一元有一个参数
二元有两个参数：operator+(Time& t1,Time& t2)
4、运算符重载的符号必须符合C++要求，不能自己虚构一个运算符，比如@
5、不能违反原来的运算规则
6、不能重载的运算符：（1）sizeof
（2）. 成员运算符 p.age
（3）* 成员指针运算符
（4）:: 作用域运算符
（5）?: 条件运算符7、只能在成员函数内重载的运算符
（1）= () [] -> 四个
（2）<< >> 只能通过全局函数和友元配合使用
（3）不要重载&&和||两个，因为无法实现短路的规则， flag&&(flag1||flag2)
学习代码
接下里代码演示一下如何去实现各个运算符的重载：
1、加号运算符重载：
#include<iostream>
using namespace std;
class Time {
public:
int m_hour;
int m_min;
Time() {
m_hour = 0;
m_min = 0;
}
Time(int hour, int min) {
m_hour = hour;
m_min = min;
}
void addtime(int hour, int min) {
m_hour += hour+(min+m_min)/ 60;
m_min = (min+m_min)% 60;
}
//调用成员方法
Time count2(Time& t) {
Time time;
time.m_hour = this->m_hour + t.m_hour + (this->m_min + t.m_min) / 60;
time.m_min= (this->m_min + t.m_min) % 60;
return time;
}
//运算符重载
/*Time operator+(Time& t) {
Time time;
time.m_hour = this->m_hour + t.m_hour + (this->m_min + t.m_min) / 60;
time.m_min = (this->m_min + t.m_min) % 60;
return time;
}*/
void showtime() {
cout << "小时：" << m_hour << "分钟：" << m_min << endl;
}
};
//全局函数运算符重载，只能与成员方法的运算符存在一个
Time operator+(Time& t1,Time& t2){
Time time;
time.m_hour = t1.m_hour + t2.m_hour + (t1.m_min + t2.m_min) / 60;
time.m_min = (t1.m_min + t2.m_min) % 60;
return time;
}
int main() {
/*Time t1(1, 20);
t1.showtime();
t1.addtime(2, 50);
t1.showtime();*/
Time t1(1, 40);
Time t2(2, 30);
//调用成员方法相加
Time t3 =t1.count2(t2);
t3.showtime();
//加号运算符重载
Time t4 = t1 + t2;
t4.showtime();
return 0;
}
2、左移运算符重载：
#include <iostream>
using namespace std;
class Person {
friend ostream& operator<<(ostream& out, Person& p);
private:
int age;
int height;
public:
Person(int age, int height) {
this->age = age;
this->height = height;
}
void show() {
cout << "年龄：" << age << " 身高：" << height << endl;
}
};
//左移运算符重载：
//void operator<<(ostream& out, Person& p) {
// cout << "年龄：" <<p.age << " 身高：" << p.height << endl;
//}
ostream& operator<<(ostream& out, Person& p) {
cout << "年龄：" << p.age << " 身高：" << p.height << endl;
return out;
}
int main() {
Person p1(21, 183);
p1.show();
cout << p1;
cout << p1 << endl;//operator(cout,p1) ..operator(void,cout),因此修改返回值即可
return 0;
}
3、递增运算符重载
#include <iostream>
using namespace std;
class Num {
// friend ostream& operator<<(ostream& out, Num& n);
friend ostream& operator<<(ostream& out, Num n);
private:
int num;
public:
Num() {
num = 0;
}
Num(int num) {
this->num = num;
}
//前置++
Num& operator++() {
num++;
return *this;
}
//后指++
Num operator++(int) {//占位参数
Num temp = *this;
num++;
return temp;
}
};
//ostream& operator<<(ostream& out, Num& n) {
// out << "数字num为：" << n.num ;
// return out;
//}
ostream& operator<<(ostream& out, Num n) {
out << "数字num为：" << n.num;
return out;
}
int main() {
Num n1(1);
cout << n1 << endl;
cout << ++n1 << endl;
cout << n1++ << endl;
cout << n1 << endl;
return 0;
}
4、指针运算符重载
#include <iostream>
using namespace std;
class Person {
private:
int age;
public:
Person(int age) {
this->age = age;
}
void show() {
cout << "年龄为：" << this->age << endl;
}
~Person() {
cout << "Person的析构函数。。。" << endl;
}
};
//智能指针类
class smartpointer {
public:
Person* operator->() {//指针重载
return this->person;
}
Person& operator*() {//指针重载
return *person;
}
smartpointer(Person *p) {
person = p;
}
Person* person;
~smartpointer() {
cout << "smartpointer的析构函数。。。" << endl;
if (person != nullptr) {
delete person;
person = nullptr;
}
}
};
int main() {
Person* p1 = new Person(21);
p1->show();
(*p1).show();
//delete p1;
smartpointer s1(p1);
s1->show();
(*s1).show();
return 0;
}
5、赋值运算符重载
#include <iostream>
#pragma warning(disable:4996)
using namespace std;
class Person {
public:
char* name;
Person& operator=(const Person& p) {//赋值运算符重载
if (this->name!= nullptr) {
delete[] this->name;
this->name = nullptr;
}
this->name = new char[strlen(p.name) + 1];
strcpy(this->name, p.name);
return *this;
}
Person() {
cout << "默认构造函数" << endl;
}
Person(const char* n) {
name = new char[strlen(n) + 1];
strcpy(name, n);
}
Person(Person& p) {
name = new char[strlen(p.name) + 1];
strcpy(name, p.name);
}
~Person() {
cout << "Person的析构函数" << endl;
if (name != nullptr) {
delete[]name;
name = nullptr;
}
}
};
int main() {
Person p1("Tom");
Person p2;
p2 = p1;
cout << "p1的名字：" << p1.name << endl;
cout << "p2的名字：" << p2.name << endl;
Person p3(p1);
cout << "P3的名字：" << p3.name << endl;
return 0;
}
6、中括号运算符重载
#include<iostream>
using namespace std;
class Array {
public:
int m_num;
int* arr;
Array(int size) {
m_num = 10;
arr = new int[size];
for (int i = 0; i < size; i++) {
arr[i] = i;
}
}
int getnum(int poisition) {
return arr[poisition];
}
int& operator[](int position) {//中括号运算符重载
return arr[position];
}
};
int main() {
Array arr1(5);
for (int i = 0; i < 5; i++) {
cout << arr1.arr[i] << endl;
}
cout << "==============" << endl;
cout << arr1.getnum(1) << endl;
cout << "==============" << endl;
cout << arr1[2] << endl;
return 0;
}
7、关系运算符重载
#include<iostream>
#include<string>
using namespace std;
class Person {
public:
string m_name;
int m_age;
Person(string name, int age) {
this->m_age = age;
this->m_name = name;
}
bool operator==(const Person& p) {//==关系运算符重载
return (this->m_name == p.m_name && this->m_age == p.m_age);
}
bool operator!=(const Person& p) {//！=关系运算符重载
return !(this->m_name == p.m_name && this->m_age == p.m_age);
}
};
int main() {
Person p1("Tom", 18);
Person p2("Lilua", 20);
cout << p1.m_name << endl;
cout << p2.m_name << endl;
if (p1 == p2) {
cout << "p1==p2" << endl;
}
else {
cout << "p1!=p2" << endl;
}
if (p1 != p2) {
cout << "p1!=p2" << endl;
}
else {
cout << "p1==p2" << endl;
}
return 0;
}
8、函数调用重载
#include <iostream>
#include<string>
using namespace std;
class Print {
public:
void operator()(string str) {//函数调用运算符重载
cout << str << endl;
}
int operator()(int a, int b) {//函数调用运算符重载
return a + b;
}
};
int main() {
Print p;
p("nihao,my world");
int sum = p(1, 2);//仿函数
cout << sum << endl;
return 0;
}
