新建 文本文档 (2).txt

C++运算符的重载举例

#include<iostream.h>
#include<string.h>
#include<stdlib.h>

//【例13.1】重载单目运算符。

class CPoint
{
 int x,y;
public:
 CPoint(int vx,int vy)
 {x=vx;y=vy;}
 CPoint(){x=0;y=0;}
 void Print();
 CPoint operator++();  //前置++运算符的声明
 CPoint operator--();  //前置--运算符的声明
};

void CPoint::Print()
{cout<<"("<<x<<","<<y<<")\t";}

CPoint CPoint::operator ++()
{     //前置++运算符的定义
 if(x<640) x++;  //A
 if(y<480) y++;  //B
 return *this;
}

CPoint CPoint::operator --()
{
 if(x>0) x--;
 if(y>0) y--;
 return *this;
}

void main13_1(void)
{
 CPoint p1(10,10),p2(200,200);
 for(int i=0;i<5;i++)
  (++p1).Print();   //C
 cout<<'\n';
 for(i=0;i<5;i++)
  (--p2).Print();
 cout<<'\n';
}

//【例13.2】 用友元函数实现例13.1中的运算符重载。

class CPoint2
{
 int x,y;
public:
 CPoint2(int vx,int vy)
 {x=vx;y=vy;}
 CPoint2(){x=0;y=0;}
 void Print();
 friend CPoint2 operator++(CPoint2 &); // 用友元函数重载运算符的声明
 friend CPoint2 operator--(CPoint2 &);
};

void CPoint2::Print()
{
 cout<<"("<<x<<","<<y<<")\t";
}

CPoint2 operator ++(CPoint2 &c)   //运算符重载的定义
{
 if(c.x<640) c.x++;
 if(c.y<480) c.y++;
 return c;
}

CPoint2 operator --(CPoint2 &c)
{
 if(c.x>0) c.x--;
 if(c.y>0) c.y--;
 return c;
}

void main13_2(void)
{
 CPoint2 p1(10,10),p2(200,200);
 for(int i=0;i<5;i++)
  (++p1).Print();     //重载运算符的使用
 cout<<'\n';
 for(i=0;i<5;i++)
  (--p2).Print();
 cout<<'\n';
}

//【例13.3】二目运算符的重载

class CThree_d
{
 int x,y,z;
public:
 CThree_d(int vx,int vy,int vz)  //构造函数
 {x=vx;y=vy;z=vz;}     
 CThree_d(){x=0;y=0;z=0;}   //无参数的构造函数
 CThree_d operator +(CThree_d t);  //重载加号"+"
 CThree_d operator -(CThree_d t);  //重载减号"-"
 CThree_d operator =(CThree_d t);  //重载赋值符"="
 void Print(){cout<<x<<"  "<<y<<"\n";}
};

CThree_d CThree_d::operator+(CThree_d t) { //定义两个对象的"+"运算
 CThree_d te;
 te.x=x+t.x;
 te.y=y+t.y;
 te.z=z+t.z;
 return te;   //返回当前对象与t对象之和
}

CThree_d CThree_d::operator-(CThree_d t) //定义两个对象的"-"运算
{
 CThree_d te;
 te.x=x-t.x;
 te.y=y-t.y;
 te.z=z-t.z;
 return te;   //返回当前对象与t对象之差
}

CThree_d CThree_d::operator=(CThree_d t) {   //将对象的值赋值给当前对象
 x=t.x;
 y=t.y;
 z=t.z;
 return *this;
}

void main13_3(void)
{
 CThree_d t1(10,10,10),t2(20,20,20),t3;
 t3=t1+t2;  //A t1与t2相加给t3
 t3.Print();  //显示t3对象的数据成员
 t3=t2=t1;  //将t1对象多重赋值给t2和t3
 t1.Print();  //显示t1,t2,t3的数据成员
 t2.Print();
 t3.Print();
}

//【例13.4】定义一个复数类CComplex，在CComplex中包含两个数据成员，
     //即复数的实数部分real和复数的虚数部分imag。用友元函数对该类的加、减、乘、除四个运算符进行重载。

class CComplex   //定义复数类
{ 
 float real,imag;  //复数的实部和虚部
public:
 CComplex(float r,float i){real=r;imag=i;}    //带参数的构造函数
 CComplex(){real=0;imag=0;}   //不带参数的构造函数
 void Print();      //复数的输出函数
 friend CComplex operator+(CComplex a,CComplex b);
    //用友元函数重载复数相加运算符
 friend CComplex operator-(CComplex a,CComplex b);
    //重载复数相减运算符
 friend CComplex operator*(CComplex a,CComplex b);
    //重载复数相乘运算符
 friend CComplex operator/(CComplex a,CComplex b);
    //重载复数相除运算符
};

void CComplex::Print()   //定义复数的输出函数
{
 cout<<real;
 if(imag>0)cout<<"+";
 if(imag!=0)cout<<imag<<"i\n";
}

CComplex operator +(CComplex a , CComplex b)
{
 CComplex temp;
 temp.real=a.real+b.real;
 temp.imag=a.imag+b.imag;
 return temp;
}

CComplex operator -(CComplex a , CComplex b)
{
 CComplex temp;
 temp.real=a.real-b.real;
 temp.imag=a.imag-b.imag;
 return temp;
}

CComplex operator *(CComplex a , CComplex b)
{
 CComplex temp;
 temp.real=a.real*b.real-a.imag*b.imag;
 temp.imag=a.real*b.imag+a.imag*b.real;
 return temp;
}

CComplex operator /(CComplex a , CComplex b)
{
 CComplex temp;
 float tt;
 tt=1/(b.real*b.real+b.imag*b.imag);
 temp.real=(a.real*b.real+a.imag*b.imag)*tt;
 temp.imag=(b.real*a.imag-b.imag*a.real)*tt;
 return temp;
}

void main13_4(void)
{
 CComplex c1(2.3,4.6) , c2(3.6,2.8) , c3;  //定义三个复数对象
 c1.Print();   //输出复数c1和c2
 c2.Print();
 c3=c1+c2;  //复数c1,c2相加，结果给c3
 c3.Print();  //输出相加结果
 c3=c2-c1;  //复数c2,c1相减，结果给c3
 c3.Print();  //输出相减结果
 c3=c2*c1;  //复数c1,c2相乘，结果给c3
 c3.Print();  //输出相乘结果
 c3=c1/c2;  //复数c1,c2相除，结果给c3
 c3.Print();  //输出相除结果
}

//【例13.5】用成员函数对自增运算符进行重载

class CIncrease
{
public:
 CIncrease(int x){Value=x;}
 CIncrease & operator ++(); //前增量
 CIncrease operator ++(int); //后增量
 void Display(){cout<<"the Value is "<<Value<<endl;}
private:
 int Value;
};

CIncrease & CIncrease:: operator ++()
{
 Value++;
 return *this;   //返回的为Value已自加的对象
}

CIncrease CIncrease::operator ++(int)
{
 CIncrease temp=*this;  //创建一个中间对象，并将它初始化为当前对象
 Value++;
 return temp;   //返回的为Value未自加的对象
}

void main13_5(void)
{
 CIncrease n(20);
 n.Display();
 ++n;
 n.Display();
 (n++).Display();
 n.Display();
}

//【例13.6】用友元函数对自增运算符进行重载

class CIncrease6
{
public:
 CIncrease6(int x){Value=x;}
 friend CIncrease6 & operator ++(CIncrease6 &);  //前增量
 friend CIncrease6 operator ++(CIncrease6 &,int);  //后增量
 void Display()
 {
  cout<<"the Value is "<<Value<<endl;
 }
private:
 int Value;
};
CIncrease6 & operator ++(CIncrease6 &a)
{
 a.Value++;
 return a;
}
CIncrease6 operator ++(CIncrease6 &a,int)
{
 CIncrease6 temp(a);
 a.Value++;
 return temp;
}
void main13_6(void)
{
 CIncrease6 n(20);
 n.Display();
 ++n;
 n.Display();
 (n++).Display();
 n.Display();
}
//【例13.7】 利用类的缺省赋值运算符产生的指针悬挂问题。

class CA
{
 char *ps;
public:
 CA(){ps=0;}
 CA(char *s)
 {
  ps=new char[strlen(s)+1];
  strcpy(ps,s);
 }
 CA & operator=(CA &b);         //如果没有该函数将会产生指针悬挂问题
 ~CA(){if(ps) delete[]ps;}
 char *GetS(){return ps;}
};

///*
CA & CA::operator=(CA &b)
{
 if(ps) delete[]ps;                
 if(b.ps) 
 {
  ps=new char [strlen(b.ps)+1];    
  strcpy(ps,b.ps);
 }
 else ps=0;
 return *this;
}
//*/

void main13_7(void)
{
 CA s1("China!"),s2("Computer!");
 cout<<"s1="<<s1.GetS()<<'\t';
 cout<<"s2="<<s2.GetS()<<'\n';
 s1=s2;                               //A
 cout<<"s1="<<s1.GetS()<<'\t';
 cout<<"s2="<<s2.GetS()<<'\n'; 
}

//【例13.8】对下标运算符进行重载，使之具有检查下表是否越界的功能。

class CArray
{
 int len;
 float *arp;
public:
 CArray(int n=0);
 ~CArray() {if (arp) delete[]arp;}
 int GetLen() const {return len;}
 void SetLen(int l){
  if(l>0){
   if(arp) delete[]arp;
   arp=new float[l];
   memset(arp,0,sizeof(float)*l);   //A
   len=l;
  }
 }
 float & operator[] (int index);      // 定义重载的下标运算符
};

CArray::CArray(int n)
{
 if(n>0){
  arp=new float[n];
  memset(arp,0,sizeof(float)*n); 
  len=n;
 }
 else{
  len=0;
  arp=0;
 }
}

float & CArray::operator[](int index)   //下表运算符的实现
{ 
 if(index>=len||index<0) {    //如果参数index超出规定的范围，则输出越界信息
  cout<<"\nError:下标"<<index<<"出界!"<<'\n';
  exit(2);
 }
 return arp[index];   //如果不越界，则返回相应的数据
}

void main13_8(void)
{
 CArray m1(10),m2(3);
 int i;
 for(i=0;i<10;i++) m1[i]=i;        //重载数组下标的使用
 for(i=1;i<11;i++)        //B
  cout<<m1[i]<<"   ";  //C
 cout<<'\n';
 m2[2]=26;
 cout<<"m2[2]="<<m2[2]<<'\n';
}

//【例13.9】通过重载函数调用运算符，实现两维数组下标的合法性的检查。

const int cor1=4;
const int cor2=4;

class CArray9{
 float arr[cor1][cor2];
public:
 CArray9()
 {memset(arr,0,sizeof(float)*cor1*cor2);}
 ~CArray9() {}
 void operator()(int i,int j,float f);     //声明函数调用运算符重载函数
 float GetElem(int i,int j);
};

void CArray9::operator()(int i,int j,float f){    //函数调用运算符重载函数的实现
 if(i>=0&&i<cor1&&j>=0&&j<cor2)
  arr[i][j]=f;
 else {
  cout<<"下标越界!\n";
  exit(3);
 }
}

float CArray9::GetElem(int i,int j){
 if(i<0||j<0||i>=cor1||j>=cor2){
  cout<<"下标越界!\n";
  exit(3);
 }
 return arr[i][j];
}

void main13_9(void)
{
 CArray9 a;
 int i,j;
 for(i=0;i<4;i++)
  for(j=0;j<4;j++)
   a(i,j,(float)i*j);   //A   使用重载的函数调用运算符
 for(i=0;i<4;i++) {
  cout<<'\n';
  for(j=0;j<4;j++){  //B
   cout<<"a["<<i<<","<<j<<"]="<<a.GetElem(i,j)<<'\t'; //C
   if((j+1)%5==0) cout<<'\n';
  }
 }
 cout<<'\n';
}

//【例13.10】new和delete运算符的重载

const maxpoints=512;

static struct block
{    
 int x,y;
 block *next;
}block1[maxpoints];     //静态结构数组，用来申请内存空间供使用

class CPoint10
{
 int x,y;
 static block *freelist;  //空闲链
 static int used;   //实际用掉的数组元素个数
public:
 CPoint10(int vx=0,int vy=0){x=vx;y=vy;}
 void *operator new (size_t);  //重载new声明
 void operator delete (void *ptr); //重载delete声明
 void Print(){cout<<x<<" "<<y<<"\n";}
};

void *CPoint10::operator new(size_t size)
{
 block *res=freelist;  //将空闲链头给res
 if(used<maxpoints)  //判断是否元素已用完
  res=&block1[used++];
 else 
  if(res!=0)
   freelist=freelist->next;
   cout<<"调用重载的new."<<endl;
 return res;
}

void CPoint10::operator delete(void *ptr)
{
 ((block *)ptr)->next=freelist;    //将待释放的内存块插入到链头前
 freelist=(block *)ptr;
    cout<<"调用重载的delete."<<endl;
}

block *CPoint10::freelist=0;     //将静态数据赋初值，空闲链初始为空
int CPoint10::used=0;       //所用的数组元素的个数初值为0

void main13_10(void)
{
 CPoint10 *pt=new CPoint10(5,7);
 pt->Print();
    delete pt;
    CPoint10 *pt1=::new CPoint10;    //调用预定义的new
    ::delete pt1;            //调用预定义的delete
}

//【例13.11】类型转换函数举例

class CRational
{
public:
 CRational(int d,int n){den=d;num=n;}
 operator double(); //声明类型转换函数，它将Crational类型型转换为double类型
private:
 int den,num;
};

CRational::operator double()
{
 return double(den)/double(num);
}

void main(void)
{
 CRational r(5,8);
 double d=4.7,e,f;
 d+=r;         //A  将CRational类型隐式转换为double类型
 e=CRational(r);    //B  将CRational类型强制转换为double类型
 f=(CRational)r;    //C  强制转换的另一种形式
 cout<<d<<'\t'<<e<<'\t'<<f<<endl;
}