C++面向对象——运算符的重载
运算符重载的基本概念
运算符重载的需求
C++预定义的运算符，只能用于基本数据类型的运算：整型、实型、字符型、逻辑型……
+、-、*、/、%、^、&、~、!、|、=、<<、>>、!=、……
在数学上，两个复数可以直接进行 +、- 等运算。
但在C++中，直接将 +或- 用于复数对象是不允许的。
有时会希望，让对象也能通过运算符进行运算。
这样代码更简洁，容易理解。
例如：
complex_a和complex_b是两个复数对象；
求两个复数之和，希望能直接写：
complex_a+complex_b
运算符重载
运算符重载就是对已有的运算符（C++中预定义的运算符）赋予多重的含义，使同一运算符作用于不同类型的数据时导致不同类型的行为。
运算符重载的目的是：扩展C++中提供的运算符的适用范围，使之能作用于对象。
同一个运算符，对不同类型的操作数，所发生的行为不同。
complex_a+complex_b //生成新的复数对象
5+4=9
运算符重载的形式
运算符重载的实质是函数重载
可以重载为普通函数，也可以重载为成员函数
把含运算符的表达式转换成对运算符函数的调用。
把运算符的操作数转换成运算符函数的参数。
运算符被多次重载时，根据实参的类型决定调用哪个运算符函数。
返回值类型 operator 运算符（形参表）
{
……
}
运算符重载的示例
#include赋值运算符的重载
赋值运算符“=”重载
有时候希望赋值运算符两边的类型可以不匹配，比如，把一个int类型变量赋值给一个Complex对象，或把一个char*类型的字符串赋值给一个字符串对象，此时就需要重载赋值运算符“=”。
赋值运算符“=”只能重载为成员函数
#include浅拷贝和深拷贝
#include原因：
String S1,S2;
S1 = "this";
S2 = "that";
S1 = S2;
如果不定义自己的赋值运算符，那么S1=S2实际上导致S1.str和S2.str指向同一地方。
如果S1对象消亡，析构函数将释放S1.str指向的空间，则S2消亡时还要释放一次，不妥。
另外，如果执行S1=“other”;会导致S2.str指向的地方被delete掉。
因此要在class String里添加成员函数：
String& operator=(const String& s) {
delete[]str;
str = new char[strlen(s.str) + 1];
strcpy(str, s.str);
return *this;
}
此外，还有需要改进的地方：
添加
if (this == &s)
return *this;
到String& operator=(const String& s)中。
完整代码
#include对operator=返回值类型的讨论
void 好不好？
String 好不好？
为什么是String &
对运算符进行重载的时候，好的风格是应该尽量保留运算符原本的特性
在C++中，赋值运算符的返回值是=左边那个变量的引用
考虑：
a=b=c;
和
(a=b)=c; //会修改a的值
分别等价于：
a.operator=(b.operator=(c));
(a.operator=(b)).operator=(c);
- 上面的String类是否就没有问题了？
为String类编写复制构造函数的时候，会面临和=同样的问题，用同样的方法处理。
String(String& s) {
str = new char[strlen(s.str) + 1];
strcpy_s(str, strlen(s.str) + 1, s.str);
}
运算符重载为友元函数
一般情况下，将运算符重载为类的成员函数，是较好的选择
class Complex {
double real, imag;
public:
Complex(double r, double i) :real(r), imag(i) {
};
Complex operator+(double r);
};
Complex Complex::operator+(double r) {
//能解释 c+5
return Complex(real + r, imag);
}
但有时，重载为成员函数不能满足使用要求，重载为普通函数，又不能访问类的私有成员，所以需要将运算符重载为友元
经过上述重载后：
Complex c;
c = c + 5; //有定义；相当于c=c.operator+(5);
但是：
c = 5 + c; //编译出错
所以，为了使得上述的表达式能成立，需要将+重载为普通函数。
Complex operator+(double r, const Complex& c) {
//能解释 5+c
return Complex(c.real + r, c.imag);
}
但是普通函数又不能访问私有成员，所以，需要将运算符+重载为友元
class Complex {
double real, imag;
public:
Complex(double r, double i) :real(r), imag(i) {
};
Complex operator+(double r);
friend Complex operator+(double r, const Complex& c);
};
可变长数组类的实现
运算符重载实例：可变长整型数组
#include流插入运算符和流提取运算符的重载
流插入运算符的重载
cout 是在 iostream 中定义的，ostream 类的对象。
“<<”能用在cout上是因为，在iostream里对“<<”进行了重载。
- 示例：
cout<<5：
ostream& ostream::operator<<(int n) {
......//输出n的代码
return*this;
}
cout<<“this”：
ostream& ostream::operator<<(const char* s) {
......//输出s的代码
return*this;
}
cout<<5<<"this";
// 调用形式：
cout.operator<<(5).operator<<("this");
假定下面程序输出为 5hello，
#include则要补写：
ostream& operator<<(ostream& o, const CStudent& s) {
o << s.nAge;
return o;
}
流提取运算符的重载
假定 c 是 Complex 复数类的对象，现在希望写 " cout << c ; "，就能以 " a + bi " 的形式输出c的值，写 " cin >> c ; "，就能从键盘接受 " a + bi " 形式的输入，并且使得 c.real = a ，c.imag = b。
#include
类型转换运算符的重载
#include自增，自减运算符的重载
自增运算符++、自减运算符–有前置/后置之分，为了区分所重载的是前置运算符还是后置运算符，C++规定：
前置运算符作为一元运算符重载
重载为成员函数：
T& operator++();
T& operator-- ();
重载为全局函数：
T1& operator++(T2);
T1& operator-- (T2);
后置运算符作为二元运算符重载，多写一个没用的参数
重载为成员函数：
T operator++(int);
T operator-- (int);
重载为全局函数：
T1 operator++(T2,int );
T1 operator-- ( T2,int);
但是在没有后置运算符重载而有前置重载的情况下，
在vs中，obj++也调用前置重载，而dev则令obj++编译出错
#include运算符重载的注意事项
- C++不允许定义新的运算符；
- 重载后运算符的含义应该符合日常习惯；
comlpex_a + complex_b;
word_a > word_b;
date_b = date_a + n;
- 运算符重载不改变运算符的优先级；
- 以下运算符不能被重载：“ . ”、“ * ”、“ :: ”、“ ? : ”、sizeof ;
- 重载运算符()、[ ]、-> 或者赋值运算符 = 时，运算符重载函数必须声明为类的成员函数。