运算符重载知识总结

1.运算符重载：

（1）重载规则：

• 不能重载的运算符     .  ::  .*  ?:  sizeof

• 可以重载的运算符

  +  -  *  /  %  ^  &  |  ~

  !  =  <  >  +=  -=  *=  /=  %

  ^=  &=  |=  <<  >>  >>=  <<=  ==  !=

  <=  >=  &&  ||  ++  --  ->*  ‘  ->

  []  ()  new  delete  new[]  delete[] 

(2)重载运算符的限制

重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：

Ø不改变运算符的优先级

Ø不改变运算符的结合性

Ø不改变运算符所需要的操作数

Ø不能创建新的运算符

（3）运算符函数可以重载为成员函数或友元函数 

1．一元运算符

Object  op    或    op  Object  （Object为操作数）

Ø重载为成员函数，解释为：

  Object . operator op ()      //注意：参数表中没有参数； 

  操作数由对象Object（即当前对象）通过this指针隐含传递

Ø重载为友元函数，解释为：

  operator  op (Object)

    操作数由参数表的参数Object提供 

2．二元运算符

ObjectL  op  ObjectR

Ø重载为成员函数，解释为：

  ObjectL . operator  op ( ObjectR )    //注意：形参表中只有一个参数； 

    左操作数由ObjectL（即当前对象）通过this指针隐含传递，右操作数由参数ObjectR传递

Ø重载为友元函数，解释为：

  operator   op ( ObjectL, ObjectR )

    左右操作数都由参数传递 

（4）用成员函数重载运算符

• 函数的原型在类的内部声明格式为

class X {
    //…
返回类型 operator运算符(形参表);
  //…
}

• 在类外定义函数的格式为

返回类型 X::operator运算符(形参表)
{
     函数体
}

（5）用友元函数重载运算符

友元函数重载运算符常用于运算符的左右操作数类型不同的情况

Ø友元函数没有this指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换

ØC++中不能用友元函数重载的运算符有

  =   （）    ［］   －>

（6）数学类中常用的运算符重载

• 自增和自减

设 A  Aobject ；
运算符 ++和 -- 有两种方式：
前置方式： ++Aobject    --Aobject
  成员函数  重载	A :: A operator++ () ; 	
    解释为：	Aobject . operator ++( ) ;
  友元函数  重载	friend A operator++ (A &) ; 
    解释为： 	operator ++( Aobject ) ;		
后置方式：  Aobject ++	 Aobject --
  成员函数  重载	A :: A  operator++ (int) ;   //注意形参；
     解释为： Aobject . operator ++( 0 ) ;   //0为伪参数；
  友元函数  重载：friend A operator++ (A &, int) ; 	
     解释为： operator++(Aobject, 0)

举例： 

成员函数重载++ ：
class  Increase
{ public :
     Increase ( ) { value=0; }
     void  display( )  const { cout<<value<<'\n'; } ;
     Increase  operator ++ ( ) ; 	     // 前置
     Increase  operator ++ ( int ) ; 	     // 后置
  private:   unsigned  value ;
};
Increase  Increase :: operator ++ ( ) 	
  { value ++ ;   return *this ; }	
Increase  Increase :: operator ++ ( int )	
 { Increase  temp;   temp.value = value ++ ;   return  temp; }

友元函数重载++
class  Increase
{ public :
     Increase ( ) { value=0; }
     void  display( )  const { cout<<value<<'\n'; } ;
     friend Increase  operator ++ ( Increase & ) ; 	 // 前置	
     friend Increase  operator ++ ( Increase &, int ) ;	 // 后置
  private:   unsigned  value ;
};
Increase  operator ++ ( Increase & a )
  { a.value ++ ;   return a ; }	
Increase  operator ++ ( Increase & a, int )
 { Increase  temp(a);   a.value ++ ;   return  temp; }

• 重载赋值运算符

Ø赋值运算符重载用于对象数据的复制

Øoperator=必须重载为成员函数

Ø重载函数原型为：

  类名  &  类名  :: operator= ( 类名) ; 

 

• 重载下标运算符[ ]

[]运算符用于访问数据对象的元素，通过重载此运算符可以定义相应对象的下标运算.用于增强操作 C++ 数组的功能。

 

1. 重载格式：    类型  类::operator[]  ( 类型) ；
2. 调用：  x[ y ]  或  x . operator [ ] ( y )

举例：

#include<iostream>
using namespace std;
class  vector
{ public :
       vector ( int  n )  {  v = new  int [ n ] ; size = n ; }
       ~ vector ( )  { delete [ ] v ; size = 0 ; }
       int & operator [ ] ( int  i )  {  return  v [ i ] ; }
   private :       
       int * v ;       int size ;
};
int main ( )
{  vector  a ( 5 ) ;
    a [ 2 ] = 12 ;	  
    cout << a [ 2 ] << endl ;
}

• 重载函数调用符（）

()运算符用于函数调用，重载括号运算符可以方便的实现很多功能。

 

1. 重载格式：     类型  类:: operator()  ( 参数表  ) ；
2. 调用：

   x ( arg1, arg2, … )   或  x . operator () (arg1, arg2, … )

3. 举例

#include <iostream>
using namespace std ;
class  F
  { public :  
        double  operator ( )  ( double x ,  double  y ) ;
  } ;
double  F :: operator ( )  ( double  x ,  double  y )
   { return   x * x + y * y ; }
int main ( )			
{ F  f  ;
   cout << f ( 5.2 , 2.5 ) << endl ;
}

• 重载流插入和流提取运算符

Ø用友元函数重载<<和>>，输出和输入用户自定义的数据类型 

 

1. 定义输出运算符“<<”重载函数的一般格式如下:

    ostream& operator<<(ostream& out，类名& obj)
    {
          out<<obj.item1;
          out<<obj.item2;
          .. .
          out<<obj.itemn;
          return out;
    }

2.定义输入运算符函数 “>>”重载函数的一般格式如下:

    istream& operator>>(istream& in，类名& obj)
    {
            in>>obj.item1;
            in>>obj.item2;
            . . .
            in>>obj.itemn;
            return in;
    }