运算符重载与函数返回引用（很详细）
运算符重载为成员函数
重载为类成员的运算符函数定义形式
函数类型 operator 运算符（形参）
{
......
}
参数个数=原操作数个数-1 （后置++、--除外）
双目运算符重载规则
- 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
- 经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)
例：复数类加减法运算重载为成员函数
- 要求:
- 将+、-运算重载为复数类的成员函数。
- 规则:
- 实部和虚部分别相加减。
- 操作数:
- 两个操作数都是复数类的对象。
源代码：
#include
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<<"("<运算符重载为非成员函数
有些运算符不能重载为成员函数，例如二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象
运算符重载为非成员函数的规则
- 函数的形参代表依自左至右次序排列的各操作数。
- 重载为非成员函数时
- 参数个数=原操作数个数（后置++、--除外）
- 至少应该有一个自定义类型的参数。
- 后置单目运算符 ++和--的重载函数，形参列表中要增加一个int，但不必写形参名。
- 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。
运算符重载为非成员函数的规则
- 双目运算符 B重载后，
表达式oprd1 B oprd2
等同于operator B(oprd1,oprd2 )
- 前置单目运算符 B重载后，
表达式 B oprd
等同于operator B(oprd )
- 后置单目运算符 ++和--重载后，
表达式 oprd B
等同于operator B(oprd,0 )
例 重载Complex的加减法和“<<”运算符为非成员函数
• 将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。 • 将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：
cout << a << b;
该输出调用的是：
operator << (operator << (cout, a), b);
源代码：
#include
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;
}
前置单目运算符重载规则
- 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。
- 经重载后，表达式 U oprd 相当于 oprd.operator U()
后置单目运算符 ++和--重载规则
- 如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
- 经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)
重载前置++和后置++为时钟类成员函数
- 前置单目运算符，重载函数没有形参
- 后置++运算符，重载函数需要有一个int形参
- 操作数是时钟类的对象。
实现时间增加1秒钟。
#include
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 && hour < 24 && 0 <= minute && minute < 60
&& 0 <= second && second < 60) {
this->hour = hour;
this->minute = minute;
this->second = second;
} else
cout << "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;
}
Clock Clock::operator ++ (int)这个函数表示后置++，函数内部定义了一个局部变量old，在其生存期结束时会被释放掉，故不能使用返回引用的定义，否则会指向被释放掉的内存空间中的不确定的值。无论重复使用多少次后置++运算，也只会改变一次原有myclock对象的值（例如myclock++++++因为只有第一次++时*this表示myclock对象，后面都是old对象，就算使用引用也是一样的，更何况没使用引用无法连续赋值）。
Clock &Clock::operator ++ (int)这个函数表示前置++，返回的是当前对象的引用，故多次调用前置++运算符时，会一直对对象myclock进行赋值。如果取消引用符号，(++++++myclock).show还是会显示三次自增后的结果，究其原因是保存的一个临时变量副本，但myclock依然是只有一次自增的结果，这种情况充分说明了引用&能使返回对象为左值。
上述程序运行结果
改动下main函数：
int main() {
Clock myClock(23, 59, 59);
cout << "First time output: ";
myClock.showTime();
cout << "Show myClock++: ";
(myClock++++++).showTime();
myClock.showTime();
cout << "Show ++myClock: ";
(++++++myClock).showTime();
myClock.showTime();
system("pause");
return 0;
}
结果如下：
*this表示当前对象，Clock & Clock::operator ++ ()中的引用表示返回的是一个本类对象的引用，即返回的是一个左值。
为了更好地理解左值的概念，我们下面举一个简单的例子：
#include
using namespace std;
class Test{
public:
//构造函数
Test(int i = 0, double j = 0.0) : m_i(i), m_j(j){
}
//赋值构造函数
Test operator=(Test &rhs){ //返回引用
this->m_i = rhs.m_i;
this->m_j = rhs.m_j;
return *this;
}
//Test operator=(Test &rhs){ //返回值
//this->m_i = rhs.m_i;
//this->m_j = rhs.m_j;
//return *this;}
int m_i;
double m_j;
};
int main(){
//1、赋初值，输出 1 2.3
Test obj1(1, 2.3);
cout << obj1.m_i << endl << obj1.m_j << endl;
cout << endl << "-------------------" << endl;
//2、未赋初值，输出0 0
Test obj2;
cout << obj2.m_i << endl << obj2.m_j << endl;
cout << endl << "-------------------" << endl;
//3、未赋初值，但是通过赋值构造函数进行了赋初值，但是注意是重复调用赋值构造函数赋初值。
Test obj3;
(obj3 = obj2 )= obj1;//这里，先进行obj3 = obj2 的操作, (赋值成功后通过return *this，返回obj2对象), 然后进行 obj3 = obj1 的操作。
cout << obj3.m_i << endl << obj3.m_j << endl;
cout << endl << "-------------------" << endl;
system("pause");
return 0;
}
函数返回引用的运行结果如下：
函数返回值的运行结果如下：
从运行结果可以看出当返回值时，函数返回值时会产生一个临时变量作为函数返回值的副本，并调用复制构造函数将*this传给这个临时变量，并且赋值得到的是一个右值，右值是不能继续赋值的，而返回引用时，引用就是obj对象本身，赋值得到一个左值，是可以继续赋值的，其原因是这是为了支持连续的=号操作，如：A a,b,c .调用(a=b)=c,这种情况下就要要求重载操作符=号必须返回一个*this的引用，这样a=b才能得到一个更新后的a,再用c对其赋值才能作用到更新 的a身上，如果不返回*this的引用，将无法完成第二次用c的那个赋值。调用成员函数时*this指向该对象本身。
下面分类讲述返回“值”和返回“引用”的不同点：
函数返回值时会产生一个临时变量作为函数返回值的副本，而返回引用时不会产生值的副本。
T f(); 返回一般的类类型，返回的类类型不能作为左值，但返回的类类型可以直接调用成员函数来修改，如function().set_Value(); 返回类类型调用复制构造函数。
const T f(); 此种类型与上述第一种相同，唯一不同的是返回的类类型不能调用成员函数来修改，因为有const限定符。
T& f(); 返回类的引用可以作为左值，并且返回的类类型引用可以直接调用成员函数来修改，返回的类类型不会调用复制构造函数。
const T& f(); 不能作为左值，不能调用成员函数修改，不会调用复制构造函数。