运算符重载
运算符重载是c++多态的一种形式，第八章介绍了c++函数重载（函数多态），本节介绍运算符重载，例如，“+”可以实现普通类型的相加，但如果现在是两个对象呢？想实现两个对象数据相加，就需要将“+”含义重载，利用关键字:operator
#include<iostream>
using namespace std;
class Num{
private:
int n;
public:
Num();
Num(int);
void show();
Num add(const Num &) const;
};
Num::Num(){
n = 0;
}
Num::Num(int t){
n = t;
}
void Num::show(){
cout<<"your number is "<<n<<" !"<<endl;
}
Num Num::add(const Num &t) const{
Num temp;
temp.n = n + t.n;
return temp;
}
int main(){
Num n1(5);
n1.show();
Num n2(10);
n2.show();
cout<<"--------------------"<<endl;
Num n3;
n3 = n2.add(n1);
n3.show();
return 0;
}
这是普通的写法，定义一个成员函数，结果返回一个对象，实现将两个对象值相加，下面介绍使用“+”重载：
#include<iostream>
using namespace std;
class Num{
private:
int n;
public:
...
Num operator+(const Num &) const;
};
Num Num::operator+(const Num &t) const{
Num temp;
temp.n = n + t.n;
return temp;
}
int main(){
Num n1(5);
n1.show();
Num n2(10);
n2.show();
cout<<"--------------------"<<endl;
Num n3;
n3 = n2 + n1;
//相当于n3 = n2 .operator+(n1);
n3.show();
return 0;
}
上述代码中，将原有的add函数去掉，使用operator+,将“+“运算符重载，函数内容不变，主函数从原有的调用add函数实现两个对象相加变为了，n3 = n2 + n1;本质也是调用了成员函数n3 = n2 .operator+(n1);
经过重载”+“运算符，编译器通过判别”+“两边数值类型决定此时的”+“的含义，并且重载后的运算符也可以多个相加：n4 = n3+n2+n1;
重载限制
运算符重载必须是已有的运算符，不能是自己定义的新运算符，并且，重载的运算符不必是成员函数，但必须至少一个操作数是用户定义的类型
- 重载后的运算符必须至少一个操作数是用户定义的类型，不能为标准类型重载运算符，例如，不能将减法运算符重载为两个double类型的值相加，显然是有问题的。
- 使用运算符时不能违反运算符原来的句法规则，例如，双目运算符不能重载为单目运算符。也不能修改其优先级，优先级不变
- 不能创建新运算符*
- 有一些特殊的运算符不能重载：成员运算符，作用域运算符等等（太多了）
- 大部分运算符都可以通过成员函数或者非成员函数进行重载，但有特殊的运算符只能通过成员函数重载：”=“赋值运算符，“（）”函数调用运算符。“[]”下标运算符，“->”通过指针访问类成员运算符
针对第五条解释一下，例如“=”赋值运算符
#include<iostream>
using namespace std;
class Num{
private:
int n;
public:
Num();
Num(int);
void show();
};
Num::Num(){
n = 0;
cout<<"hello world"<<endl;
}
Num::Num(int t){
n = t;
cout<<"this is mine"<<endl;
}
void Num::show(){
cout<<"your number is "<<n<<" !"<<endl;
}
int main(){
Num n1;
return 0;
}
结果表示，如果定义一个类对象，并没有初始化，会调用默认构造函数。但我们在加上这样一条语句：
int main(){
Num n1;
n1 = 25
return 0;
}
本意是将25赋值给对象n1，但此时n1是类对象，25是int类型数据，类型不匹配，类对象的赋值必须通过构造函数，所以，这里应该会出现语法错误，但结果是：
可以发现，编译器并没有报错，而且调用了我们定义的有参数构造函数，事实上，编译器已经默认对“=”运算符进行重载了，n1 = 25；会将25看作构造函数的参数，去匹配符合条件的的构造函数，但我们如果自行给“=”运算符进行重载：
class Num{
private:
int n;
public:
...
void operator=(int);
};
void Num::operator=(int m){
n = m;
cout<<"this is yours!"<<endl;
}
int main(){
Num n1;
n1 = 21;
return 0;
}
可以发现此时调用了我们重载后的运算符函数，而不是原有的构造函数。
综上可知，赋值运算符本身在类中就有重载的构造函数意思，但如果我们在类外重载了赋值运算符，此时编译器将产生歧义，不知道是调用其构造函数，还是调用我们在类外重载后的赋值运算符函数，因此，赋值运算符不能在类外重载，与此相同，其余三个运算符是因为这样的原因，而不能在类外重载。
在说明一点，对于其他运算符在类外重载时，如果类对象要使用该操作，那么需要将数据变量从私有变为共有，因为类外定义的重载函数是无法访问类私有变量的，虽然这种重载方式可以，但破坏了类的封装性，因此不建议，所以，操作类对象的运算符重载函数最好定义为类成员函数。
友元
现在对乘号运算符进行重载，使其实现一个类对象与整数相乘，是对象值翻倍：
#include<iostream>
using namespace std;
class Num{
private:
int n;
public:
Num();
Num(int);
Num operator*(int);
void show();
};
Num::Num(){
}
void Num::show(){
cout<<"this is "<<n<<endl;
}
Num Num::operator*(int t){
Num n1;
n1.n = n* t;
return n1;
}
Num::Num(int t){
n = t;
}
int main(){
Num n1(5);
n1.show();
Num n2;
n2 = n1*2;
n2.show();
return 0;
}
这里有个问题，n2 = n1*2；本质是n1调用了运算符重载函数，那如果翻过来呢？-----n2 = 2 *n1;理论上乘法具有交换律，但2不是类对象，所以语法错误，但为了满足乘法交换律，使其无错误：
第一种就是对用户提醒，只能按Num * int这种方式编写，属于一种服务器友好-客户警惕解决方案，与oop无关。
第二种，重新以非成员函数的形式重载乘法运算符，其参数顺序第一个为int，第二为类对象，结果返回一个类对象，但这样就要访问类数据，虽然可以将其变为共有，但从oop来看，不推荐这样，其实还有一种投机取巧的方法：
Num operator*(int t, Num &n){
return n*t;
}
但正规来说，为了使该非成员函数可以访问类私有数据------可以定义一种特殊的非成员函数—友元函数，该函数不是成员函数，但可以访问私有变量。
友元函数的声明在类中，前面加上friend，但并不是成员函数，因此定义时不用作用域运算符，当作普通函数定义即可，前面也不用加friend：
#include<iostream>
using namespace std;
class Num{
private:
int n;
public:
...
friend Num operator*(int, Num &); //声明友元函数
};
Num operator*(int t, Num &m){
//定义友元函数
Num n1;
n1.n = m.n* t;
return n1;
}
int main(){
Num n1(5);
n1.show();
Num n2;
n2 = 2*n1;
n2.show();
return 0;
}
这样就解决了int*Num的问题。
重载<<运算符
#include<iostream>
using namespace std;
class Time{
private:
int hours;
int min;
public:
void show();
Time();
Time(int, int);
};
Time::Time(){
hours = 0;
min = 0.0;
}
Time::Time(int h, int m){
hours = h;
min = m;
}
void Time::show(){
cout<<"your time is "<<hours<<" hours: "<<min<<" minutes!"<<endl;
}
int main(){
Time t1(6,23);
Time t2;
t1.show();
t2.show();
return 0;
}
这是一个简单的打印时间的程序，可以发现，显式时间都是要调用类成员函数show实现，但c++中打印数据都是使用<<实现的，如果要做到cout<<t1;将类对象作为变量直接打印，因此，需要对<<运算符进行重载，这里就需要理解<<运算符打印数据的本质了，cout是os类的对象,实际就是重载了<<运算符，相当于调用了cout的一个成员函数。
这里我们想直接利用cout打印对象t1：cout<<t1;根据上面的知识，对顺序是有要求的，按常理来说，我们需要对cout对象所在库中<<运算符进行重载，但cout是标准库中的对象，这显然是不可取的。因此就要调换顺序：t1<<cout;但这样看起来也很别扭。所以，为了满足顺序要求：cout<<t1;,就不能将<<重载函数声明为成员函数，将其声明为友元函数。
class Time{
private:
int hours;
int min;
public:
...
friend void operator<<(ostream &, const Time &);
};
void operator<<(ostream & os, const Time &t){
os<<"your time is "<<t.hours<<" hours: "<<t.min<<" minutes!";
}
int main(){
Time t1(6,23);
Time t2;
cout<<t1;
return 0;
}
这样就实现了cout<<t1;但是，cout<<支持连续输出的，因此我们也想实现连续输出类对象.
cout<<a<<b;
上述代码中(cout<<a)是一个整体，其返回对象又是一个cout，因此可以连续输出，根据这个原理，我们可以给重载函数设置返回值：
class Time{
public:
..
friend ostream & operator<<(ostream &, const Time &); //从void变为ostream
};
ostream & operator<<(ostream & os, const Time &t){
os<<"your time is "<<t.hours<<" hours: "<<t.min<<" minutes!"<<endl;
return os;//增加返回值
}
int main(){
Time t1(6,23);
Time t2;
cout<<t1<<t2;//连续输出
return 0;
}
这样就是实现了对运算符<<的重载，可以发现重载函数声明为成员函数还是非成员函数，与我们想实现的功能有关，大部分都可以声明为成员函数，根据特殊需求，可以声明为非成员函数。
类的自动转换与强制类型转换
在学习数据类型时，我们知道，不同类型数据之间可以相互转变。
Time t1;
t1 = 12;
Time是已经定义的类，有一个int类型的私有变量，上述代码表面看来是想给t1对象赋值为12，但我们知道，类对象的赋值需要调用构造函数，而上述代码是：对象 = int。这从原理上是错误的，但是，c++支持把int数据转换为类对象的形式。
前提是类有一个能够接受一个参数的构造函数。程序将使用该构造函数创建一个临时的类对象，并将12作为初始值，然后将该临时变量的内容赋值给左侧的类对象中我们把这种形式称为-------隐式转换，因为它是自动进行的，没有显式强制类型转换。
这种形式只能是接受一个默认参数的构造函数才可以，如果接受两个参数，其中一个为默认值。也可以隐式转换。
虽然说隐式转换是一个不错的特性，但有时候出于某种需要，不允许这种类型转换，c++也是支持关闭这种自动转换的，使用关键字----explicit，在对应构造函数声明前加上该关键字即可：
explicit Time(int);
这样就关闭了隐式转换，但依然允许显式转换：
Time t1;
t1 = Time(15);
t1 = (Time) 15;//旧形式
上述介绍了将int数据传递给相应的类对象，那么反过来，如何将一个类对象转换为相应的int数据：
Time t1(15);
int a = t1; //?????
这样做是可以，但不是使用构造函数，构造函数适用于从其他类型转换为类，要进行相反的转换，使用特殊的c++运算符函数------转换函数。
定义转换函数后，就可以使用下面的转换：
Time t1;
int a = int(t1);
int b = (int) t1;
int c = t1;//编译器自己决定t1转换类型
转换函数定义要注意几点：
- 转换函数必须是类方法
- 转换函数不能指定参数
- 转换函数不能有参数
- 原型为：operator typename();
#include<iostream>
using namespace std;
class Tength{
private:
double mete;
double mmete;
public:
Tength();
Tength(double);
Tength(double, double);
void show();
operator int(); // 转换函数
};
Tength::operator int(){ //转换函数的定义
return mete;
}
Tength::Tength(){
}
Tength::Tength(double m){
mete = m;
mmete = 0.0;
}
Tength::Tength(double m, double mm){
mete = m;
mmete = mm;
}
void Tength::show(){
cout<<"this is "<<mete<<" metes,"<<mmete<<" mmetes!"<<endl;
}
int main(){
Tength t1(23,19.2);
Tength t2 = 25; //前面讲到的int赋值给类对象
t1.show();
t2.show();
int a = t2; //本节说的转换函数，将t2转换为int类型
cout<<"a = "<<a<<endl;
return 0;
}
要注意一点，上述代码只有一个int的转换函数，所以在使用时是隐式转换，没有显示转换。如果代码中有多个转换函数类型，在使用时一定要显式转换：
a = double(t1);不然会出现二义性，即编译器不知道要将类对象转换为哪种类型数据。
与关闭类的隐式自动转换一样，转换函数可以关闭隐式转换，c++11中也可以使用关键字explicit，方法与关闭类的自动转换一样：
explicit operator int();
这样使用转换函数必须调用函数。还有另一种方法，用一个功能相同的非转换函数替换该转换函数即可，这样想转换类对象时，必须调用该函数，也算是一种显式转换形式了。
最后一点，无论是类的自动转换还是转换函数，最好关闭其隐式转换，防止自己因为疏忽写错某代码，但因为存在转换函数或者类的自动转换，而还可以正常运行，从而导致代码不符合原本意图。
2778
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
