operator运算符重载

运算符重载

一、作为类成员函数的重载

　　为了能进行类对象和一个整型值的加法运算，需要写一个类的成员函数来重载双目加法(+)运算符。该函数在类中的声明如下：
　　Date operator + (int) const;
　　函数的声明指出，返回值是一个Date类对象，函数名是运算符+，只有一个整型参数，而且函数是常量型的。当编译器发现某个函数以加上前缀operator的真实运算符作为函数名，就会把该函数当作重载运算符函数来处理。如果在表达式中，该运算符的左边是一个类对象，右边是一个参数类型的一个对象，那么重载运算符函数就会被调用。调用形式如下：
　　Date dt(6,9,2005);
　　dt=dt+100;
　　也可以显式的调用重载运算符函数：
　　dt.operator + (100);
　　下面代码重载了双目加法运算符来计算一个整数和一个Date类对象之和，并且返回Date类对象。
　　#include iostream.h
　　class Date
　　{
　　int mo,da,yr;
　　static int dys[];
　　public:
　　 Date(int m=0,int d=0,int y=0)
　　 { mo=m; da=d; yr=y;}
　　 void display() const
　　 { cout< Date operator + (int) const;
　　 };
　　int Date::dys[]={31,28,31,30,31,30,31,31,30,31,30,31};
　　Date Date::operator+(int) const
　　{
　　Date dt=*this;
　　n+=dt.da;
　　while(n>=dys[dt.mo-1])
　　{
　　n-=dys[dt.mo-1];
　　if(++dt.da==13)
　　{
　　dt.mo=1;
　　dt,yr++;
　　}
　　}
　　dt.da=n;
　　return dt;
　　}
　　int main()
　　{
　　Date olddate(1,1,2005);
　　Date newdate;
　　newdate=olddate+100;
　　newdate.display();
　　return 0;

　　}

二、非类成员的运算符重载
　　在重载运算符的原则中说到，要保持运算符的可交换性。而上面的程序只允许Date类对象在运算符的左边而整型值在右边，不支持下面的语句：
　　Date newdate=100+olddate;
　　所以，仅仅靠一个类的成员重载运算符是无法实现上面功能的。对重载双目运算符的类成员函数来说，总是认定调用函数的对象位于运算符左边。不过，我们可以再写一个非类成员的重载运算符函数，可以规定Date类的对象在运算符右边，而别的类型在运算符左边。例如，我们可以这样在类的外部定义一个函数：
　　Date operator + (int n,Date& dt)
　　下面代码在原先的基础上增加了一个非类成员函数来实现双目加法运算符的重载。
　　#include iostream.h
　　class Date
　　{
　　int mo,da,yr;
　　static int dys[];
　　public:
　　Date(int m=0,int d=0,int y=0)
　　{ mo=m; da=d; yr=y;}
　　void display() const
　　{ cout< Date operator + (int) const;
　　};
　　int Date::dys[]={31,28,31,30,31,30,31,31,30,31,30,31};
　　Date Date::operator+(int) const
　　{
　　Date dt=*this;
　　n+=dt.da;
　　while(n>=dys[dt.mo-1])
　　{
　　n-=dys[dt.mo-1];
　　if(++dt.da==13)
　　{
　　dt.mo=1;
　　dt,yr++;
　　}
　　}
　　dt.da=n;
　　return dt;
　　}
　　Date operator + (int n,Date& dt)
　　{
　　return dt+n;
　　}
　　int main()
　　{
　　Date olddate(1,1,2005);
　　Date newdate;
　　newdate=olddate+100;
　　newdate.display();
　　return 0;
　　}
　　上面的例子中非类成员重载运算符函数调用了类中的重载+运算符来实现加法运算。如果类当中没有提供这样的函数，那么非类成员的重载运算符函数将被迫访问类的私有数据来实现加法运算。这样的话，需要把这个函数声明为类的友元，如下：
　　class Date
　　{
　　friend Date operator + (int n,Date&);
　　};
　　上例中重载运算符函数声明了全部两个参数，这是因为它不是类的成员，因此它不能作为类的成员函数被调用，就缺少了一个隐含的参数。
　　第一个重载加法运算符函数也可以用类的友元函数来实现。作为一种约定，这通常把所有为类重载的运算符都设定为该类的友元。
　　例子中只给出了重载加法的代码，我们同样可以来重载减法，乘除法等等。
导读：本文主要介绍为类成员函数的重载、非类成员的运算符重载、重载关系运算符、其他赋值运算符。 　　


三、重载关系运算符
如果想要对两个日期进行比较，比如出现下面这样的代码：
　　if(olddate 可以向上面用类似的方法重载关系运算符
　　#include iostream.h
　　class Date
　　{
　　int mo,da,yr;
　　public:
　　Date(int m=0,int d=0,int y=0)
　　{ mo=m; da=d; yr=y;}
　　void display() const
　　{ cout< int operator == (Date& dt) const;
　　int operator < (Date& dt) const;
　　};
　　int Date::operator== (Date& dt) const
　　{
　　return (this->mo==dt.mo && this->da==dt.da && this->yr==dt.yr);
　　}
　　int Date::operator < (Date& dt) const
　　{
　　if(this->yr == dt.yr)
　　{
　　if(this->mo == dt.mo) return this->da < dt.da;
　　return this->mo < dt.mo;
　　}
　　return this->yr < dt.yr;
　　}
　　int main()
　　{
　　Date date1(2,14,2005);
　　Date date2(6,9,2005);
　　Date date3(2,14,2005);
　　if(date1 {
　　date1.display();
　　cout< date2.display();
　　}
　　cout< if(date1==date3)
　　{
　　date1.display();
　　cout< date3.display();
　　}
　　return 0;
　　}
　　可以类似的重载其他关系运算符，如!=

　　int operator != (Date& dt) { return !(*this==dt);}

四、其他赋值运算符
　　#include iostream.h
　　class Date
　　{
　　int mo,da,yr;
　　static int dys[];
　　public:
　　Date(int m=0,int d=0,int y=0)
　　{ mo=m; da=d; yr=y;}
　　void display() const
　　{ cout< Date operator + (int) const;
　　Date operator +=(int)
　　{ *this=*this+n; return *this;}
　　};
　　int Date::dys[]={31,28,31,30,31,30,31,31,30,31,30,31};
　　Date Date::operator+(int) const
　　{
　　Date dt=*this;
　　n+=dt.da;
　　while(n>=dys[dt.mo-1])
　　{
　　n-=dys[dt.mo-1];
　　if(++dt.da==13)
　　{
　　dt.mo=1;
　　dt,yr++;
　　}
　　}
　　dt.da=n;
　　return dt;
　　}
　　int main()
　　{
　　Date olddate(1,1,2005);
　　olddate+=100;
　　olddate.display();
　　return 0;

　　}

（完）