重载操作符 operator overloading 学习笔记

重载操作符，只是另外一种调用函数的方法和表现方式，在某些情况它可以让代码更简单易读。注意不要过度使用重载操作符，除非它让你的类更简单，让你的代码更易读。

1语法

如下：

其中友元，关键字不是必须的，但是当你需要读参数类的内部变量时候，声明就需要加上friend.

friend Money operator +(const Money & amount1,const Money& amount2);
    friend bool operator ==(const Money & amount1,const Money& amount2);
    
    friend Money operator -(const Money & amount1,const Money& amount2);
    friend Money operator -(const Money & amount1);
//

参数写成上面的形式，在上篇博客中解释到，是为了提高效率，同时保证不改变该类的参数。

 

 

2重载操作符的一些规则：

a.重载一个操作符时，至少一个参数属于类的类型

b.重载的操作符，可以是一个类的友元，也可以是该类的成员，也可以是一个普通（非友元）函数。

c.不能新建一个操作符，只能对现有操作符进行重载，如：+，-，*，/,%等

d.不能改变操作符接受的参数数目。如上文，都是对 ‘-’ 进行重载，当有两个参数时候，进行的是a-b的重载，有一个参数时候，进行的是-a的重载。

 

 

3重载>>  and <<

语法和上面类似。注意，返回的是一个流，对于一个流，就不能简单的返回留的值，它的值可能是一个文件，或一个屏幕等，所以你要返回流本身，而不是流的值。所以必须在返回类型的名称末尾添加&,即“引用”。这表示返回的是对象本身，而不是对象的值。

friend istream& operator >>(istream& ins,Money& amount);
    friend ostream& operator <<(ostream& out,Money& amount);

 

 

4示例代码

//下面是一个小实例，表示moeny类，并重载了一些操作符，供参考

// Money.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<cstdlib>
#include<cctype>

using namespace std;



class Money{
public:
    
    friend Money operator +(const Money & amount1,const Money& amount2);
    friend bool operator ==(const Money & amount1,const Money& amount2);
    
    friend Money operator -(const Money & amount1,const Money& amount2);
    friend Money operator -(const Money & amount1);

    friend istream& operator >>(istream& ins,Money& amount);
    friend ostream& operator <<(ostream& out,Money& amount);

    Money(){all_cents=0;}

    Money(long dollars,int cents){
        all_cents=dollars*100+cents;
    }

    Money(long dollars):all_cents(dollars*100){}

    double get_value() const{ return all_cents;}

    void input(istream& ins);
    void output(ostream& outs) const;

private:
    long all_cents;
};
Money operator +(const Money & amount1,const Money& amount2){
    
    
    return Money(0,amount1.all_cents+amount2.all_cents);
}
bool operator ==(const Money & amount1,const Money& amount2){
    
    
    return amount1.all_cents == amount2.all_cents;
}
void Money::input(istream& ins){
    cout<<"please enter dollars:";
    long dol,cent;
    ins>>dol;
    cout<<endl<<"please enter cents:";
    ins>>cent;

    all_cents=cent+dol*100;

}
istream& operator >>(istream& ins,Money& amount){

    cout<<"please enter dollars:";
    long dol,cent;
    ins>>dol;
    cout<<endl<<"please enter cents:";
    ins>>cent;

    amount.all_cents=cent+dol*100;
    return ins;
}

void Money::output(ostream& out) const{
    out<<"all the money you have is:"<<all_cents<<"  cents"<<endl;
}

ostream& operator <<(ostream& out,Money& amount){


    out<<"all the money you have is:"<<amount.all_cents<<"  cents"<<endl;
    return out;

}
Money operator -(const Money & amount1,const Money & amount2){
    
    return Money(0,amount1.all_cents-amount2.all_cents);
        
}
Money operator -(const Money & amount1){
    return Money(0,-amount1.all_cents);

}
int _tmain(int argc, _TCHAR* argv[])
{

    Money a(10),b(3,20);

    Money c=a+b;

    Money d=c-b;
    



    cout<<a<<b<<c<<d<< (d==a);
    return 0;
}

 

5返回值优化 Return optimization

如果’+’重载，如果如下实现，那么要经历3个过程：

a.  temp调用构造函数

b.   temp把值赋给要返回的值，需要调用“复制构造函数”

c.函数结束时候，temp调用析构函数

Money operator +(const Money & amount1,const Money& amount2)
{
Money temp;
temp.all_cents=amount1.all_cents+amount2.all_cents;
return temp;
}

 

如程序改下成如下形式（上面示例代码的形式）：

Money operator +(const Money & amount1,const Money& amount2){
    
    
    return Money(0,amount1.all_cents+amount2.all_cents);
}

这样，编译器会直接调用构造函数用于返回的对象，它甚至不需要调用析构函数，因为你没有真正构造一个本地的对象。这种直接返回值得方法，叫做“返回值优化（return value optimization)”.

 

本人水平有限，怀着分享学习的态度发表此文，欢迎大家批评，交流。感谢您的阅读。

欢迎转载本文，转载时请附上本文地址：  http://www.cnblogs.com/Dzhouqi/p/3393257.html                                    

另外：欢迎访问我的博客 http://www.cnblogs.com/Dzhouqi/