重载
C++语言规定：
- 只能对已有的运算符重载，不能增加新的运算符。
- 重载的运算符不会改变原先的优先级和结合性。
- 成员函数
- 友元函数
(::,.,*,->,?:这5个符号不能重载)
//*为读值符号,不是乘号
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
friend int operator+(jxb t1,jxb t2);
};
jxb a2(11),b2(1),c2;
int operator+(jxb t1,jxb t2)
{
// return t1.getz()+t2.getz();
return t1.m_z+t2.m_z;
}
int main()
{
c1=a1+b1;//operator+(a1,b1);=>operator+(int i1,int i2);
c1=a2+b2;//c1=operator+(a2,b2);=>int operator+(jxb t1,jxb t2);
cout<<"c1 = "<<c1<<endl;
}
//结果为:
//c2=12;
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
};
jxb a2(11),b2(1),c2;
jxb operator+(jxb t1,jxb t2)
{
return t1.getz()+t2.getz();
}
int main()
{
c1=a1+b1;//operator+(a1,b1);=>operator+(int i1,int i2);
c2=a2+b2;//c1=operator+(a2,b2);=>int operator+(jxb t1,jxb t2);
cout<<"c2 = "<<c2.getz()<<endl;
}
//结果为:
//c2 =12;
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
int operator+(jxb t2)
{
return m_z+t2.m_z;
}
};
jxb a2(14),b2(1),c2;
int main()
{
c1=a1+b1;//operator+(a1,b1);=>operator+(int i1,int i2);
c1=a2+b2;//c1=operator+(a2,b2);=>int operator+(jxb t1,jxb t2);
cout<<"c1 = "<<c1<<endl;
}
//结果为:
//c1=15;
- 总结: 成员函数的operator比全局的operator少一个形参.
哪些符号不能重载
::,.,->,*,?:这5个符号不能重载
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
/* int operator+(jxb t2)
{
return m_z+t2.m_z;
}*/
friend jxb& operator++(jxb& t);
};
jxb a2(14),b2(1),c2;
jxb& operator++(jxb& t)
{
++t.m_z;
return t;
}
int main()
{
c2=++a2;
cout<<"a2 = "<<a2.getz()<<endl;
cout<<"c2 = "<<c2.getz()<<endl;
}
//结果为:
//a2 = 15;
//c2 = 15;
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
/* int operator+(jxb t2)
{
return m_z+t2.m_z;
}*/
friend jxb& operator++(jxb& t);
friend jxb operator++(jxb& t,int);
};
jxb a2(14),b2(1),c2;
jxb& operator++(jxb& t)
{
++t.m_z;
return t;
}
jxb operator++(jxb& t,int)
{
jxb z(t.m_z);
++t.m_z;
return z;
}
int main()
{
// c2=++a2;
c2=a2++;
cout<<"a2 = "<<a2.getz()<<endl;
cout<<"c2 = "<<c2.getz()<<endl;
}
//结果为:
//a2 = 15;
//c2 = 14;
#include<iostream>
using namespace std;
int a1,b1,c1;
class jxb
{
int m_z;
public:
jxb(int z)
{
m_z=z;
}
jxb()
{
m_z=10;
}
int getz()
{
return m_z;
}
void setz(int z)
{
m_z=z;
}
friend jxb& operator++(jxb& t);
friend jxb operator++(jxb& t,int);
friend ostream& operator<<(ostream& c,jxb& z);
};
jxb a2(14),b2(1),c2;
jxb& operator++(jxb& t)
{
++t.m_z;
return t;
}
jxb operator++(jxb& t,int)
{
jxb z(t.m_z);
++t.m_z;
return z;
}
ostream& operator<<(ostream& c,jxb& z)
{
c<<z.m_z;
return c;
}
int main()
{
c2=a2++;
cout<<a2<<endl;//operator<<(cout,a2);=>operator<<(ostream&,jxb&);
}
//结果为:
//a2 = 15;
+由值返回，++由引用返回
- 对于operator+()，两个对象相加， 不改变其中任一个对象。而且它必须生成一个结果对象来存放加法的结果，并将该结果对象以值的方式返回给调用者。
- operator++()确实修改了它的参数， 而且其返回值要求是左值，这个条件决定了它不能以值返回
前增量与后增量的区别
- 使用前增量时，对对象(操作数)进行增量修改，然后再返回该对象。
- 使用后增量时，必须在增量之前返回原有的对象值。
- 后增量运算符中的参数int只是为了区别前增量与后增量， 除此之外没有任何作用。
- 前后增量操作的意义，决定了其不同的返回方式。前增量运算符返回引用，后增量运算符返回值。
阶段总结
- 操作符重载把操作符的作用扩展到对象类型
- 为了访问类的保护对象,需要把重载函数定义成友员
- 操作符重载可以是成员函数
- 前增量和后增量通过一个形参区分
#include<iostream>
#include<math.h>
using namespace std;
class complex
{
private:
double real;
double imag;
public:
complex()
{
real=5;
imag=5;
}
complex(double m)
{
real=m;
imag=0;
}
complex(double r,double n)
{
real=r;
imag=n;
}
double displayreal()
{
return real;
}
double displayimag()
{
return imag;
}
complex operator+(complex c);
complex operator-(complex c);
};
complex complex::operator+(complex c)
{
complex tm;
tm.real=real+c.real;
tm.imag=imag+c.imag;
return tm;
}
complex complex::operator-(complex c)
{
complex tm;
tm.real=real-c.real;
tm.imag=imag-c.imag;
return tm;
}
int main()
{
complex a1,b1,c1;
c1=a1+b1;
cout<<c1.displayreal()<<"+"<<c1.displayimag()<<"*"<<"i"<<endl;
return 0;
}
//根据定义的参数形式,寻找相匹配的函数
//此时结果为:10+10*i;
