C++学习笔记（Day13 第八章多态性——运算符重载）_综合

运算符重载的规则

思考：用“+”、“-”能够实现复数的加减运算吗？
实现复数加减运算的方法 ——重载“+”、“-”运算符
运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。
C++ 几乎可以重载全部的运算符，而且只能够重载C++中已经有的。
不能重载的运算符：“.”、“.*”、“::”、“?:”

重载之后运算符的优先级和结合性都不会改变。

运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。
例如：使复数类的对象可以用“+”运算符实现加法；
使时钟类对象可以用“++”运算符实现时间增加1秒。
重载为类的非静态成员函数；
重载为非成员函数

运算符重载为成员函数

重载为类成员的运算符函数定义形式

双目运算符重载规则

如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)

例8-1 复数类加减法运算重载为成员函数

要求: 将+、-运算重载为复数类的成员函数。
规则: 实部和虚部分别相加减。
操作数: 两个操作数都是复数类的对象。

#include <iostream>
using namespace std;
class Complex { //定义基类
public:Complex(double r =0.0,double i = 0.0):real(r),imag(i){}//运算符+重载成员函数Complex operator + (const Complex &c2)const;//运算符-重载成员函数Complex operator - (const Complex &c2)const;void display() const;//输出复数
private:double real;//复数实部double imag;//复数虚部
};
Complex Complex::operator+(const Complex &c2)const{//创建一个临时无名对象作为返回值return Complex(real+c2.real,imag + c2.imag);
}
Complex Complex::operator-(const Complex &c2)const{//创建一个临时无名对象作为返回值return Complex(real- c2.real,imag-c2.imag);
}
void Complex::display() const {cout << "(" << real << "," << imag << ")" << endl;
}
int main() { //程序主函数Complex c1(5,4),c2(2,10),c3;cout << "c1 = ";c1.display();cout << "c2 = ";c2.display();c3 = c1 - c2;//使用重载运算符完成复数减法cout << "c3 = c1 - c2 = ";c3.display();c3 = c1 + c2;//使用重载运算符完成复数加法cout << "c3 = c1 + c2 = ";c3.display();return 0;
}

补充：类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。

单目运算符福重载规则

前置单目运算符重载规则

如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。
经重载后，表达式 U oprd 相当于 oprd.operator U()

后置单目运算符 ++和--重载规则

如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)
通过参数表区分前置和后置

例8-2 重载前置++和后置++为时钟类成员函数

前置单目运算符，重载函数没有形参
后置++运算符，重载函数需要有一个int形参
操作数是时钟类的对象。
实现时间增加1秒钟。

前置++i与后置i++的区别

#include <iostream>
using namespace std;
//时钟类定义
class Clock{
public:Clock(int hour = 0,int minute = 0,int second = 0);void showTime() const;//前置单目运算符重载Clock& operator ++();//后置单目运算符重载Clock operator ++(int);
private:int hour,minute,second;
};
Clock::Clock(int hour,int minute,int second){if(0 <= hour <= 24 && 0<= minute <= 60 && 0 <= second <=60){this->hour = hour;this->minute = minute;this->second = second;}elsecout << "Time error!"<< endl;
}
//显示时间
void Clock::showTime() const {cout << hour << ":" << minute << ":" << second << endl;
}
//前置自增，先增一后使用
Clock & Clock::operator++() {second++;if(second >= 60){second -= 60; minute++;if(minute >= 60){minute -= 60;hour = (hour + 1) % 24;}}return *this;//返回的是左值，当前对象的引用
}
//后置自增，先使用后增一（不太准确）
Clock Clock::operator++(int) {Clock old = *this;++(*this);//调用前置“++”运算符return old;//返回的是右值，一个副本
}
int main() {Clock myClock(23,59,59);cout << "First time output: ";myClock.showTime();cout << "Show myClock++: ";(myClock++).showTime();cout << "Show ++myClock: ";(++myClock).showTime();return 0;
}

运算符重载为非成员函数的规则

函数的形参代表依自左至右次序排列的各操作数。
重载为非成员函数时
参数个数=原操作数个数（后置++、--除外）
至少应该有一个自定义类型的参数。
后置单目运算符++和--的重载函数，形参列表中要增加一个int，但不必写形参名。
如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。

例8-3 重载Complex的加减法和“<<”运算符为非成员函数

将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。
将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：

        cout << a << b;

该输出调用的是：

        operator << (operator << (cout, a), b);

//8_3.cpp 
#include <iostream> 
using namespace std; 
class Complex { 
public: Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { } 
friend Complex operator+(const Complex &c1, const Complex &c2); 
friend Complex operator-(const Complex &c1, const Complex &c2); 
friend ostream & operator<<(ostream &out, const Complex &c); 
private: double real; //复数实部 double imag; //复数虚部 
}; 
Complex operator+(const Complex &c1, const Complex &c2){ return Complex(c1.real+c2.real, c1.imag+c2.imag); 
} 
Complex operator-(const Complex &c1, const Complex &c2){ return Complex(c1.real-c2.real, c1.imag-c2.imag); 
} 
ostream & operator<<(ostream &out, const Complex &c){ out << "(" << c.real << ", " << c.imag << ")"; return out; 
} 
int main() { Complex c1(5, 4), c2(2, 10), c3; cout << "c1 = " << c1 << endl; cout << "c2 = " << c2 << endl; c3 = c1 - c2; //使用重载运算符完成复数减法 cout << "c3 = c1 - c2 = " << c3 << endl; c3 = c1 + c2; //使用重载运算符完成复数加法 cout << "c3 = c1 + c2 = " << c3 << endl; return 0; 
}

C++学习笔记（Day13 第八章 多态性——运算符重载）