运算符重载

c++编译器提供默认赋值运算重载函数。

默认的拷贝构造函数与默认赋值操作重载函数的的异同点：

构造函数是用来初始化新对象的；而赋值重载函数是用来给一个已经存在的对象赋值的。——调用场景不同。

默认拷贝是浅拷贝，只是成员变量的简单复制（成员变量空间创建并赋值）；默认赋值重载是成员变量的简单赋值（成员变量间的赋值）。所以对于有指针类型的成员变量也只是指针变量本身的值被赋值，它所指向的空间并没被创建。也没有往它指向的空间里赋值。

 

运算符重载的方式：友元（可以使用类私有成员）+成员函数(比友元函数少一个形参)

//承认操作符重载的实质是一个函数
//操作数（单目、双目）

class complex
{
    public:
        friend complex operator+(complex , complex);
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 

complex  operator+ (complex c1,complex c2)
{
     complex c;
     c.a = c1.a + c2.a;
     c.b = c1.b + c2.b;
     return c;
}

complex d_c,d_c1,d_c2;
d_c = d_c1 + d_c2;

//承认操作符重载的实质是一个函数
//操作数（单目、双目）

class complex
{
    public:
        complex operator+(complex , complex);
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 

complex::complex operator+ (complex c2)
{
     complex c;
     c.a = this->a + c2.a;
     c.b = this->b + c2.b;
     return c;
}

complex::complex operator+ (complex c2)
{
     complex c;
     c.a = a + c2.a;     //不写this
     c.b = b + c2.b;  　　//不写this
     return c;
}

complex d_c,d_c1,d_c2;
d_c = d_c1 + d_c2;     //调用实质：d_c = d_c1.operator+(d_c2);

对于二元运算符：如果是成员函数，那么符号的左操作数是通过this传递。

 

重载++、--:

class complex
{
    public:
        friend complex operator++(complex); //++dum;
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 


complex operator++(complex dum)
{
    ++dum.a; 
    ++dum.b;
    return dum;
}

complex operator++(complex& dum)
{
    ++dum.a; 
    ++dum.b;
    return dum;
}

complex& operator++(complex& dum)
{
    ++dum.a; 
    ++dum.b;
    return dum;
}

class complex
{
    public:
        complex operator++(); //++dum;
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 


complex::complex operator++()
{
    ++a;
    ++b;
    return *this;
}

class complex
{
    public:
        friend complex operator++(complex，int); //dum++;
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 


complex operator++(complex& c1,int) //int为占位符
{
    complex tmp = c1;
    c1.a++; 
    c1.b++;
    return tmp; //返回加1之前的值
}

complex c1,c2,c3;
c2 = c1++;

class complex
{
    public:
        complex operator++(int); //dum++;
        complex():a(1),b(2){}
    private:
        int a;
        int b;
} 


complex::complex operator++(int) //int为占位符
{
    complex tmp = *this;
    this->a++;
    this->b++;
    return tmp; //返回加1之前的值
}

complex c1,c2,c3;
c2 = c1++;

操作符重载函数，如果用友元函数形式实现，那么操作符的操作数，只能通过形参传递；如果使用成员函数实现，那么操作符的前操作数是通过this传递的（对于双目运算符，而单目运算符的操作数总是通过this传递） 

 

返回类型是引用还是对象本身；形参是用引用还是用对象本身，没有严格的语法问题，关键看实际计算需要。