c++学习笔记十三

 运算符重载
     
        1 为自已的类实现运算符
 
          运算符重载
          运算符重载允许把标准运算符（+-*/等）应用于定制数据类型的对像,
        即编写一个函数，重新定义每个运算符，使之每次应用于类的对象时，就执


行         指定的操作
           示例代码如下(如果重新定义<运算符):
              orerator<();
        注：如果是字母运算符，要在关键字和运算符之间有一个空格
          
          可以重载的运算符
          不允许发明新运算符,不能修改优先级和操作个数
                           不能重载的运算符
===========================================================================


=
        运算符                     |                   符号
===========================================================================


=
    作用域解析运算符               |                    ::
===========================================================================


=
    条件运算符                     |                    ?:
===========================================================================


=
    直接成员访问运算符             |                    .
===========================================================================


=
    解除类成员指针引用运算符       |                    .*
===========================================================================


=
    sizeof运算符                   |                    sizeof
===========================================================================


=
      
            注：此外还不能重载预处理指令运算符#
                              标志传送符号    ##


           实现重载运算符(重载<运算符的函数原型)示例代码如下:
           
           class Box{
                  public:
    //比较两个box对象
                     bool  operator<(const Box & Box) const;
                     //参数是运算符的右操作数, 当前指针this 是左操作数    


 
            };
            使用的示例代码如下:
            if(box1.operator<(box2)){ //提高程序的可读性
                cout<<"box1 is less than box2"
                    <<endl;
            }


 
            例子程序
            //头文件Box.h
   #ifndef BOX_H 
            #define BOX_H
   class Box{
 public:
                     Box(double aLength=1.0,double aWidth=1.0,double 


aHeight);//构造器
                  //成员方法
                  double volume() const;
                  double getWidth() const;
                  double getLength() const;
                  double getHeight() const;

                  //重载运算符,定义在函数内效率高
           bool operator<(const Box & aBox) const{
       return volume()<aBox.volume(); 
                  }


   //成员变量
                  private:
                     double length;
                     double width;
                     double height;
            }




             //实现代码 Box.cpp
             #include "Box.h"
             
             //构造器
              Box::Box(double aLength,double aWidth,double aHeight):length


(aLength),width(aWidth),height(aHeight){}
            
             //成员函数
             double Box::volume() const{
                  return length*width:height;
             }
             
             //getXXX()
             double Box::getLength() const{return length;}
             double Box::getWidth() const{return width;}
             double Box::getHeight() const{return height;}
             //有了重载运算符就可以省去compareVolume()
          
          
         全局运算符函数
         inline bool operator<(const Box & Box1,const Box &Box2){
             return  Box1.Volume()<Box2.Volume();
         }
        
         提供对运算符的全部支持
          
          示例化码: bool operator<(double value) const;
           实现部分:
              inline bool Box::operator<(double aValue) const{
                  return volume<aValue;
              }
           还可以实现为:(两个操作数可以是double类型的任意表达式)
              inline bool Box::operator<(const double aValue,const Box & 


aBox) const{
                return  aValue<aBox.volume();
      }
           


         运算符函数术语
         重载运算符函数的一般形式如下：
            返回类型 operator X(类型 右操作数); 
         使用非成员函数实现二元运算符时，其形式如下:
            返回类型 operator X(类型 左操作数，类型 右操作数);  
         如果type类型左操作数不实现为type类的成员, 该函数就必需实现为全局运


算符函数,其型式如下：
             返回类型 operator X(类型 左操作数,类类型 右操作数)
         一元运算符实现为类的成员函数时，一般不要参数（递增和递减例外）,其


形式如下：
             类类型& operator Op();
         如果实现为全局运算符时，只有一个参数(操作数)
             类类型& operator Op(类类型 &) 
         
        
        重载赋值运算符   = 
         注:在动态分配内存的类中，如果类的函数在自由存储区内动态分配内存,就


应实现副本的构造函数,赋值运算符和析构函数
           
          实现赋值运算符 (14章代码实例)
           
           
        重载算术运算符
       
          例如重载加号运算符
            头文件的定义 示例代码如下：
              Box operator+(const Box& aBox) const;
            实现文件的定义，示例代码如下：
              inline Box::operator+(const Box& aBox) const{
                     return Box(length>aBox.length?length:aBox.length,
                                width>aBox.width?width:aBox.width,
                                height+aBox.height);
              }
          
           根据一个运算符实现另一个运算符
               重载+=运算符
               inline Box::operator+=(const Box & right){
   length=length>right.length?length:right.length;
                    width=width>right.width?width:right.width;
                    height+=rigth.length;
                    return *this;
               }
             然后在实现+=的基础上再实现+,示例代码如下:
               inline Box::operator+(const Box & aBox) const{
                    return Box(*this)+=aBox;
               }
           
            重载下标运算符[]
               头文件定义如下:
                class TruckLoad(){
                     public:
                         Box operator[] (int index) const;
                };
              
                实现文件定义如下：
                  Box TruckLoad::operator[](int index) const{
                       if(index<0){
                          cout<<endl
                              <<"Negative index";
                              exit(1);    
                       }
                       
                       Package* pPackage=pHead;
                       int count=0;
                       do{
                          if(index==count++){
                              return *pPackage->pBox;
                            }
               
                       }while(pPackage=pPackage->pNext);
       
                       cout<<endl
                           <<"Out of range index";
                       exit(1);
   }


         重载类型转换
            定义一个运算符函数，把类类型转换为另一种类型。
                class object{
                    public:
                      operator Type();//从object类型转换为type
                 };
                 从type1类型到type2类型
                 Type2(const Type1& theObject);
          
          重载递增递减运算符(++,--)
            因为它们放在操作数之前和之后的情况是不一样的,因此每个运算符都需


要两个函数.示例代码如下：
           class Object{
              public:
                Object & operator++();//前缀
                const Object operator++(int);//后缀(防止编译Object ++ ++这


样的表达示)
           }
         
            智能指针(实际上是一个类对象)
               重载解除引用运算符*和间接成员运算符->
                为Box对象定义智能指针，头文件如下(BoxPtr)：
                #ifndef BOXPTR_H
                #define BOXPTR_H
                #include "List.h"


                class BoxPtr{
                     //构造器
                    public:
                      BoxPtr(TruckLoad & load);
                      Box & operator*() const;
                      Box * operator->() const;
                      Box * operator->() const;
                      const Box * operator++(int);


                    BoxPtr();
                    BoxPtr(BoxPtr&);
                    BoxPtr& operator=(const BoxPtr&);


   private:
                      Box * pBox;
                      TruckLoad & rLoad;
                }
               
        语句中是怎么调用的 
           BoxPtr pLoadBox(aTruckLoad);
           double  boxVol=pLoadBox->volume();
        第二个语句等价于
           double  boxVol=(pLoadBox.operator->())->volume();
        多出一个operator->()函数必须返回Box * 类型的指针
        
          实现智能指针(BoxPtr.cpp文件)
          
          #include <iostream>
          #include "List.h"
          #include "BoxPtr.h"
          using std::cout;
          using std::endl;
 
          BoxPtr::BoxPtr(){
               pBox=rLoad.getFirstBox();
 }
          
          解除引用运算符,示例代码如下:
  Box& BoxPtr::operator*(){
             if(pBox){
        return *pBox();
              }else{
                cout<<endl<<"Derferencing null BoxPtr";
                exit(1);
              }
           }
          注：如果不支持exit()这种用法,应使用return *pBox()替换
               
          间接成员选择运算符
            Box* BoxPtr::operator->(){
              return pBox;
           } 
          
          使用智能指针 
           #include <iostream>
           #include <stdlib>
           #include <ctime>


           using std::cout;
           using std::endl;  
           
           #include "Box.h"
           #include "List.h"
           #include "BoxPtr.h"
 
           inline int random(int count){
                 return 1+static_cast<int>(count*static_cast<double>


(std::rand())/(RAND_MAX+1.0));
           }
           
           int main(){
              const int dimLimit=100; 
              std::srand((unsigned)std::time(0));
          
              const int boxCount=20;
     Box boxes[boxCount]; 
              //创建20个box对象
    for(int i=0;i<boxCount;i++){
                boxes[i]=Box(random(dimLimit),random(dimLimit),randon


(dimLimit));
                TruckLoad load=TruckLoad(boxes,boxCount);
                //创建一个智能指针，含20个Box对象
                BoxPtr pLoadBox(load);
                Box maxBox=* pLoadBox;
                if(pLoadBox){
                   cout<<endl
                       <<"Volume of first Box is"
                       <<pLoadBox->volume();
                while(++pLoadBox){
                    if(maxBox<* pLoadBox){
                        maxBox=* pLoadBox;
   }
   cout<<endl
                        <<"The larguagest Box is "
                        <<maxBox.getLength()<<"by"
                        <<maxBox.getWidth()<<"by"
                        <<maxBox.getHeight()<<"with volume"
                        <<maxBox.volume();
                }
                }
    }
           }  
            
           重载运算符new和delete(当需要巨量的对象需要分配内存时，而且每个对


象都需要少量内存时)
    
           实现new的标准方法是分配一大块内存，再按需把它分为许多块小内存
           class Data{
               //重载运算符
               public:
                   void * operator new(size_t Size);
                   void operator delete(void * object,size_t size);
          }
         
           要从针对类的new运算符中调用全局new运算符
            void * operator new(){
               pSpace=::new char(size);
  }