C++运算符重载教学.docx

C++运算符重载教学.docx

《C++运算符重载教学.docx》由会员分享，可在线阅读，更多相关《C++运算符重载教学.docx（11页珍藏版）》请在冰豆网上搜索。

C++运算符重载教学

一。

作为类成员函数的重载

　　为了能进行类对象和一个整型值的加法运算，需要写一个类的成员函数来重载双目加法（+）运算符。

该函数在类中的声明如下：

　　Dateoperator+（int）const;

　　函数的声明指出，返回值是一个Date类对象，函数名是运算符+，只有一个整型参数，而且函数是常量型的。

当编译器发现某个函数以加上前缀operator的真实运算符作为函数名，就会把该函数当作重载运算符函数来处理。

如果在表达式中，该运算符的左边是一个类对象，右边是一个参数类型的一个对象，那么重载运算符函数就会被调用。

调用形式如下：

　　Datedt（6,9,2005）;

　　dt=dt+100;

　　也可以显式的调用重载运算符函数：

　　dt.operator+（100）;

　　下面代码重载了双目加法运算符来计算一个整数和一个Date类对象之和，并且返回Date类对象。

　　#includeiostream.h

　　classDate

　　{

　　intmo,da,yr;

　　staticintdys[];

　　public:

　　Date（intm=0,intd=0,inty=0）

　　{mo=m;da=d;yr=y;}

　　voiddisplay（）const

　　{cout

　　};

　　intDate:

:

dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

　　DateDate:

:

operator+（int）const

　　{

　　Datedt=*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;

　　returndt;

　　}

　　intmain（）

　　{

　　Dateolddate（1,1,2005）;

　　Datenewdate;

　　newdate=olddate+100;

　　newdate.display（）;

　　return0;

　　}

　　二。

非类成员的运算符重载

　　在重载运算符的原则中说到，要保持运算符的可交换性。

而上面的程序只允许Date类对象在运算符的左边而整型值在右边，不支持下面的语句：

　　Datenewdate=100+olddate;

　　所以，仅仅靠一个类的成员重载运算符是无法实现上面功能的。

对重载双目运算符的类成员函数来说，总是认定调用函数的对象位于运算符左边。

不过，我们可以再写一个非类成员的重载运算符函数，可以规定Date类的对象在运算符右边，而别的类型在运算符左边。

例如，我们可以这样在类的外部定义一个函数：

　　Dateoperator+（intn,Date&dt）

　　下面代码在原先的基础上增加了一个非类成员函数来实现双目加法运算符的重载。

　　#includeiostream.h

　　classDate

　　{

　　intmo,da,yr;

　　staticintdys[];

　　public:

　　Date（intm=0,intd=0,inty=0）

　　{mo=m;da=d;yr=y;}

　　voiddisplay（）const

　　{cout

　　};

　　intDate:

:

dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

　　DateDate:

:

operator+（int）const

　　{

　　Datedt=*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;

　　returndt;

　　}

　　Dateoperator+（intn,Date&dt）

　　{

　　returndt+n;

　　}

　　intmain（）

　　{

　　Dateolddate（1,1,2005）;

　　Datenewdate;

　　newdate=olddate+100;

　　newdate.display（）;

　　return0;

　　}

　　上面的例子中非类成员重载运算符函数调用了类中的重载+运算符来实现加法运算。

如果类当中没有提供这样的函数，那么非类成员的重载运算符函数将被迫访问类的私有数据来实现加法运算。

这样的话，需要把这个函数声明为类的友元，如下：

　　classDate

　　{

　　friendDateoperator+（intn,Date&）;

　　};

　　上例中重载运算符函数声明了全部两个参数，这是因为它不是类的成员，因此它不能作为类的成员函数被调用，就缺少了一个隐含的参数。

　　第一个重载加法运算符函数也可以用类的友元函数来实现。

作为一种约定，这通常把所有为类重载的运算符都设定为该类的友元。

　　例子中只给出了重载加法的代码，我们同样可以来重载减法，乘除法等等。

导读：

本文主要介绍为类成员函数的重载、非类成员的运算符重载、重载关系运算符、其他赋值运算符。

　　三。

重载关系运算符

如果想要对两个日期进行比较，比如出现下面这样的代码：

　　if（olddate可以向上面用类似的方法重载关系运算符

　　#includeiostream.h

　　classDate

　　{

　　intmo,da,yr;

　　public:

　　Date（intm=0,intd=0,inty=0）

　　{mo=m;da=d;yr=y;}

　　voiddisplay（）const

　　{cout

　　intoperator<（Date&dt）const;

　　};

　　intDate:

:

operator==（Date&dt）const

　　{

　　return（this->mo==dt.mo&&this->da==dt.da&&this->yr==dt.yr）;

　　}

　　intDate:

:

operator<（Date&dt）const

　　{

　　if（this->yr==dt.yr）

　　{

　　if（this->mo==dt.mo）returnthis->da

　　returnthis->mo

　　}

　　returnthis->yr

　　}

　　intmain（）

　　{

　　Datedate1（2,14,2005）;

　　Datedate2（6,9,2005）;

　　Datedate3（2,14,2005）;

　　if（date1{

　　date1.display（）;

　　cout

　　}

　　cout

　　{

　　date1.display（）;

　　cout

　　}

　　return0;

　　}

　　可以类似的重载其他关系运算符，如!

=

　　intoperator!

=（Date&dt）{return!

（*this==dt）;}

　　四。

其他赋值运算符

　　#includeiostream.h

　　classDate

　　{

　　intmo,da,yr;

　　staticintdys[];

　　public:

　　Date（intm=0,intd=0,inty=0）

　　{mo=m;da=d;yr=y;}

　　voiddisplay（）const

　　{cout

　　Dateoperator+=（int）

　　{*this=*this+n;return*this;}

　　};

　　intDate:

:

dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

　　DateDate:

:

operator+（int）const

　　{

　　Datedt=*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;

　　returndt;

　　}

　　intmain（）

　　{

　　Dateolddate（1,1,2005）;

　　olddate+=100;

　　olddate.display（）;

　　return0;

　　}

c++运算符重载实例详解（原创）初学者请进。

运算符重载实例详解（原创）

1.哪些运算符可以用作重载？

几乎所有的运算符都可用作重载。

具体包含：

算术运算符：

=，-，*，/，%，++，--

位操作运算符：

—，|，~，^,<<,>>;

逻辑运算符：

！

&&,||;

比较运算符：

>,<,>=,<=,==,!

=

赋值运算符：

=，+=，-=,*=,%=,\=^=,<<=,>>=;

其他运算符：

[]，（）->,',new,delete,new[],delete[],->*.

运算符有两种重载形式：

成员函数形式和友元函数形式。

这两种形式都可访问类中的私有成员。

以下为实例说明，请仔细阅读哦，对你很有用。

（这可都是我在devc++上运行过的，保证正确！

！

！

）

一元运算符

#include

#include

usingnamespacestd;

classInteger{

   longi;

   Integer*This（）{returnthis;}     

public:

   Integer（longn=56）:

i（n）{}          

   friendconstInteger&operator+（constInteger&a）;

   friendconstIntegeroperator-（constInteger&a）;

   friendconstIntegeroperator~（constInteger&a）;

   friendInteger*operator&（Integer&a）;

};

constInteger&operator+（constInteger&a）{

     cout<<"+Integer\n"<

     returna;     

}

constIntegeroperator-（constInteger&a）{

     cout<<"-Integer\n"<

     returnInteger（-a.i）;     

}

constIntegeroperator~（constInteger&a）{

     cout<<"~Integer\n"<

     returnInteger（~a.i）;     

}

Integer*operator&（Integer&a）{

     cout<<"&Integer\n"<

     returna.This（）;     

}

voidf（Integera）{

   +a;

   -a;

   ~a;

   Integer*ip=&a;    

}

intmain（）

{

   Integera;

   f（a）;

   system（"pause"）;

}

二元运算符

运算符重载复数的四则运算符的例子。

复数由实部和虚部构造。

#include

#include

usingnamespacestd;

classplural{

   longleft;

   longright;

public:

plural（）{left=right=0;}

   plural（longn,longm）{

  left=n;

  right=m;

}          

   friendconstpluraloperator+（constplural&l,constplural&r）;

   friendconstpluraloperator-（constplural&l,constplural&r）;

   friendconstpluraloperator*（constplural&l,constplural&r）;

  //friendconstIntegeroperator/（constInteger&l,constInteger&r）;

friendvoidprint（constplural&p）;

};

constpluraloperator+（constplural&l,constplural&r）{

cout<<"+plural\n";

returnplural（l.left+r.left,l.right+r.right）;     

}

constpluraloperator-（constplural&l,constplural&r）{

cout<<"-plural\n";

returnplural（l.left-r.left,l.right-r.right）;     

}

constpluraloperator*（constplural&l,constplural&r）{

cout<<"*plural\n";

returnplural（l.left*r.left-r.right*r.right,l.left*r.left+l.right*r.right）;    

}

//constpluraloperator/（constplural&l,constplural&r）{

//cout<<"/pluralInteger\n";

//returnplural（l.i/r.i）;     

//}

voidprint（constplural&i）{

     if（i.right<0）

     {

   cout<

     }else

   cout<

}

intmain（）

{

   plurali（2.0,3.0）,ii（4.0,-5.0）,iii;

   iii=i+ii;

cout<<"\ni+ii=";

print（iii）;

   system（"pause"）;

}

赋值运算符重载为成员函数的例子

有的双目运算符还是重载为成员函数为好，例如，赋值运算符=

#include

#include

usingnamespacestd;

classA{

  public:

         A（）{x=y=0;}

         A（inti,intj）{x=i;y=j;}

         A（A&p）{x=p.x;y=p.y;}

         A&operator=（A&p）;

         intgetX（）{returnx;}

         intgetY（）{returny;}

  private:

         intx,y;             

};

A&A:

:

operator=（A&p）{

     x=p.x;

     y=p.y;

     cout<<"=opratorcalled.\n";

     return*this;

}

intmain（intargc,char*argv[]）

{

   Aa（4,3）;

   Ab;

   b=a;

   cout<

   system（"PAUSE"）;

   returnEXIT_SUCCESS;

}

重载增1减1运算符

它们又有前缀各后缀运算两种，为了区分这两种运算，将后缀运算符视为双目运算符。

obj++或obj--

被看作为：

obj+0或obj-0

将这两种运算符重载于类的成员函数，见下例。

#include

#include

usingnamespacestd;

classcounter{

public:

     counter（）{v=0;}

     counteroperator++（）;

     counteroperator++（int）;

     voidprint（）{cout<

  private:

     unsignedv;

};

countercounter:

:

operator++（）{

  v++;

  return*this;

}

countercounter:

:

operator++（int）{

  countert;

  t.v=v++;

  returnt;

}

intmain（intargc,char*argv[]）

{

   counterc;

   for（inti=0;i<8;i++）

    c++;

    c.print（）;

   for（inti=0;i<8;i++）

     ++c;

     c.print（）;

   system（"PAUSE"）;

   returnEXIT_SUCCESS;

}

执行该程序输出的结果：

8

16

重载函数调用运算符

可以将函数调用运算符（）看成是下标运算符[]的扩展。

函数调用运算符可以带0个至多个参数。

#include

#include

usingnamespacestd;

classcounter{

public:

     doubleoperator（）（doublex,doubley）const;

};

doublecounter:

:

operator（）（doublex,doubley）const{

  return（x+5）*y;

}

intmain（intargc,char*argv[]）

{

   counterc;

   cout<

   system（"PAUSE"）;

   returnEXIT_SUCCESS;

}

执行该程序输出如下结果：

14.3

说明：

f（1.5,.2.2）被编译为f.operator（）（1.5,2.2）

const，这是因为重载函数不改变被操作对象的状态。