C++重载

重载

C++语言规定：

• 重载的运算符要保持原运算符的意义。

1. 只能对已有的运算符重载，不能增加新的运算符。
2. 重载的运算符不会改变原先的优先级和结合性。

• 运算符重载的形式

1. 成员函数
2. 友元函数

• 允许重载的运算符

(::,.,*,->,?:这5个符号不能重载)
//*为读值符号,不是乘号

#include
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 = "<

#include
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 = "<

#include
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 = "<

• 总结: 成员函数的operator比全局的operator少一个形参.

哪些符号不能重载

::,.,->,*,?:这5个符号不能重载

• 前缀++

#include
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 = "< 
   
operator++()确实修改了它的参数， 而且其返回值要求是左值，这个条件决定了它不能以值返回
 
   
  
 
前增量与后增量的区别
 
 
 
  
 
   
使用前增量时，对对象(操作数)进行增量修改，然后再返回该对象。
 
   
使用后增量时，必须在增量之前返回原有的对象值。
 
   
后增量运算符中的参数int只是为了区别前增量与后增量， 除此之外没有任何作用。
 
   
前后增量操作的意义，决定了其不同的返回方式。前增量运算符返回引用，后增量运算符返回值。
 
  
 
 
 
 
阶段总结
 
 
 
  
 
   
操作符重载把操作符的作用扩展到对象类型
 
   
为了访问类的保护对象,需要把重载函数定义成友员
 
   
操作符重载可以是成员函数
 
   
前增量和后增量通过一个形参区分
 
  
 
 
 
 
 
  
 
   
作业,实现一个虚数
 
   
虚数=实部+虚部
 
  
 
 
 
 
#include
#include
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<