运算符重载
基本规则
可以重载的运算符：
不可重载的运算符：
//返回类型 operator后面加运算符(参数列表)
//eg. Integer operator+(Integer l, Integer r);
class Integer{
public:
Integer(int n = 0) : i(n) {}
const Integer operator+(const Integer& v){ //在类中定义运算符重载函数
return Integer(i+v.i);
}
const void print_i(){ cout << i << endl; }
private:
int i;
};
int main()
{
Integer x(10),y(20);
Integer z = x + y; //相当于 x.operator+(y)
z.print_i(); //打印结果
z = x + 3; //ok，打印出13
z.print_i();
z = 3 + 7; //ok,将10传给构造函数创建一个Integer对象
z.print_i();
z = 3 + y; //error，3不是Integer对象，没有实现运算符重载，会报错
z.print_i();
return 0;
}
由上面的例子可以看到，z = 3 + y会报错，因为3不是Integer对象，双目运算符重载调用的是运算符左边的对象的运算符重载函数。可将成员函数修改为全局函数(在类中将该函数添加friend关键字)。
class Integer{
public:
Integer(int n = 0) : i(n) {}
friend const Integer operator+(const Integer& l, const Integer& r);
const void print_i(){ cout << i << endl; }
private:
int i;
};
const Integer operator+(const Integer& l, const Integer& r){ //全局函数
return Integer(l.i + r.i);
}
int main()
{
Integer x(10),y(20);
Integer z = x + y; //相当于 x.operator+(y)
z.print_i(); //打印结果
z = x + 3; //ok，打印出13
z.print_i();
z = 3 + 7; //ok,将10传给构造函数创建一个Integer对象
z.print_i();
z = 3 + y; //ok，会调用全局函数
z.print_i();
return 0;
}
是否将运算符重载设置为成员函数的基本规则：
1、单目运算符应该被设置为成员函数
2、= () [] -> ->*必须设置为成员函数
3、赋值运算符应该被设置为成员函数
4、其他的双目运算符应该作为全局函数(如+、-、*、/等)
原型
常见运算符的原型：
运算符++和–，++和–也是可以实现运算符重载，怎么区分是++x还是x++？
首先要了解a++和++a的区别：
a++可以这么理解：先对a原来的值(a=5)拷贝一份，接着执行a = a + 1，最后将之前拷贝的副本赋值给b，于是就有b = 5, a = 6
++a可以这么理解：先执行a = a + 1，最后将新的结果a = 7赋值给b，于是就有b = 7, a = 7
int main()
{
int a = 5;
int b = a++; //b = 5, a = 6
cout << "b = " << b << ",a = " << a <<endl;
int c = ++a; //a = 7, c = 7
cout << "c = " << c << ",a = " << a <<endl;
return 0;
}
输出结果：
++、–运算符的重载
按照这样的运算规则对++运算符进行重载。
class Integer{
public:
Integer(int n = 0) : i(n) {}
friend const Integer operator+(const Integer& l, const Integer& r);
friend const Integer operator-(const Integer& l, const Integer& r);
const int get() { return i;}
const Integer& operator++(); //++x，++做前缀
const Integer operator++(int); //x++，int并不会作为形参传递，返回的是一个新的Integer对象，所以不加引用
const Integer& operator--(); //--x，--做前缀
const Integer operator--(int); //x--，int并不会作为形参传递
private:
int i;
};
//对'+'运算符重载
const Integer operator+(const Integer& l, const Integer& r){ //全局函数
return Integer(l.i + r.i);
}
//直接对原来对象的值进行修改
const Integer& Integer::operator++(){
*this = *this + 1; //调用'+'的重载函数
return *this; //返回一个integer对象，加&是是因为这是对原来的对象的直接修改
}
//返回值不加引用是因为返回的是一个局部对象，return后实际上会执行一个拷贝构造函数操作
const Integer Integer::operator++(int){ //返回一个新创建的对象
Integer old(*this);
++(*this); //调用上面的++重载函数
return old;
}
//实现--x
const Integer& Integer::operator--(){
*this = *this - 1;
return *this;
}
//实现x--
const Integer Integer::operator--(int){
Integer old(*this); //拷贝构造函数
--(*this); //调用--x的重构函数
return old;
}
int main()
{
Integer x(5);
Integer y = x++;
cout << "y.i = " << y.get() << ", x.i = " << x.get() << endl;
Integer z = ++x;
cout << "z.i = " << z.get() << ", x.i = " << x.get() << endl;
return 0;
}
可以看到输出结果与上个例子结果一致。
关系运算符的重载
通过==重载来实现!=的重载，通过<重载来实现>、<=、>=的重载，这么写的好处是充分利用已有函数，后期修改只需修改两个函数。
class Integer{
public:
Integer(int n = 0) : i(n) {}
friend const Integer operator+(const Integer& l, const Integer& r); //友元函数
friend const Integer operator-(const Integer& l, const Integer& r);
const int get() { return i;}
const Integer& operator++(); //++x，++做前缀
const Integer operator++(int); //x++，int并不会作为形参传递，返回的是一个新的Integer对象，所以不加引用
const Integer& operator--(); //--x，--做前缀
const Integer operator--(int); //x--，int并不会作为形参传递
//overload relational operators
bool operator==(const Integer& r) const;
bool operator!=(const Integer& r) const;
bool operator<(const Integer& r) const;
bool operator<=(const Integer& r) const;
bool operator>=(const Integer& r) const;
bool operator>(const Integer& r) const;
private:
int i;
};
// overload relational operators definition
bool Integer::operator==(const Integer& r) const{
return (i == r.i);
}
bool Integer::operator!=(const Integer& r) const{
return !(*this == r); //调用==的重载函数
}
bool Integer::operator<(const Integer& r) const{
return i < r.i;
}
bool Integer::operator>(const Integer& r) const{
return r < *this; //调用<的重载函数
}
bool Integer::operator<=(const Integer& r) const{
return !(r < *this); //调用>的重载函数, <=就是>取反
}
bool Integer::operator>=(const Integer& r) const{
return !(*this < r); //调用<的重载函数, >=就是<取反
}
int main()
{
Integer x(5);
Integer y(7);
cout << boolalpha << (x < y) <<endl; //调用x.operator<(y)，boolalpha使得打印出bool类型
cout << boolalpha << (x > y) <<endl;
cout << boolalpha << (x == y) <<endl;
return 0;
}
输出结果：
类型转换
用户定义的类型转换：当构造函数是单个参数或运算符转换的隐式类型转换时编译器会进行隐式转换。
C++类型转换：
对于用户定义的类型，有两种方法实现T==>C。一是C中存在用T作为单个参数传递的构造函数，二是T中存在用运算符重载的方式实现T==>C。
构造函数实现自动类型转换
#include <iostream>
class One{
public:
One() {}
};
class Two{
public:
Two(const One&){}
};
void f(Two){}
int main()
{
One one;
f(one); //wants a Two, has a one
return 0;
}
f()函数需要Two类型的对象作为参数，当将对象one作为参数传递时，编译器会查找是否存在用类One来构建类Two的构造函数，这时会调用Two::Two(const One&)，结果就是将Two的对象作为参数传递给f()。
自动类型转换可以避免定义两个不同版本的f()函数，但是自动类型转换会隐式地调用Two的构造函数，会对程序的效率有影响。
避免编译器使用构造函数实现自动类型转换需要加关键词explict，如下：
class One{
public:
One() {}
};
class Two{
public:
explicit Two(const One&){}
};
void f(Two){}
int main()
{
One one;
//f(one); //error
f(Two(one)); //ok，Two(one)创建了一个临时的对象将其作为参数传递给f()
return 0;
}
运算符重载实现自动类型转换
class Three{
private:
int i;
public:
Three(int ii) : i(ii) {}
};
class Four{
private:
int x;
public:
Four(int xx) : x(xx) {}
operator Three() const { return Three(x); } //函数名就是要转换的类型，所以最前面不用加返回值类型
};
void g(Three) {}
int main()
{
Four four(1);
g(four); //实现Four==>Three，再将转换后的对象传递给g()
g(1); //调用Three(1,0)
return 0;
}
自动类型转换的缺陷
当上述提到的两种自动类型转换的情况同时存在时，就会产生一个模糊的转换，两种方式都能实现隐式的自动类型转换，编译器不知道使用哪种方式，就会出现报错的情况
class Orange{
public:
Orange(const Apple&); //Convert Apple to Orange
};
class Apple{
public:
operator Orange() const; //Convert Apple to Orange
};
void f(Orange){ }
int main()
{
Apple a;
//f(a); //ambiguous conversion
return 0;
}
类型转换总结
尽量不要使用这种自动类型转换，函数调用时会出现各种问题，使用显式类型转换函数，如double ToDouble() const来代替operator double() const。
参考资料：
Thinking in C++，Chapter 12 Operator Overloading
浙江大学翁凯C++教程
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
