操作符重载下

operator关键字能将操作符定义为全局函数，本质即函数重载，类的成员函数是否可作为操作符重载的函数？

class Complex
{
    int a;
    int b;
public:
    Complex(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    Complex operator+ (const Complex& c2);
};
Complex Complex::operator+ (const Complex& c2)	//隐式第一个参数为this指针，指向c1 
{
    Complex ret(0, 0);
    ret.a = this->a + c2.a; 		//ret.a=a+c2.a
    ret.b = this->b + c2.b;
    return ret;
}
int main(int argc, char *argv[])
{
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c1 + c2;	//等价于c1.operator+(c2) 
    return EXIT_SUCCESS;
}

成员函数重载操作符比全局函数重载操作符少一个参数，即左操作数，不需friend关键字
什么时候使用全局函数重载操作符？什么时候使用成员函数重载操作符？
当无法修改左操作数的类时，只能使用全局函数进行重载，如要将<<使用成员函数方式重载，则需将ostream& operator<< (ostream& out, const Complex& c)对应的成员函数添加至ostream类，但ostream为c++标准库定义的类无法修改
=, [], ()和->操作符只能通过成员函数重载(赋值操作符、数组操作符、函数调用操作符)
编译器为每个类默认提供=，但其为简单成员变量值复制，若a1=a2，则导致指针mSpace内容同，析构函数中释放两次同一内存
------/Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_
class Array
{
private:
    int mLength;
    int* mSpace;
public:
    Array(int length);
    Array(const Array& obj);
    int length();
    ~Array();
    int& operator[](int i);
    Array& operator= (const Array& obj);
    bool operator== (const Array& obj);	//数组相等或不等比较(长度、内容) 
    bool operator!= (const Array& obj);
};
#endif

------/Array.cpp

#include <stdio.h>
#include "Array.h"
Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    mLength = length;
    mSpace = new int[mLength];
}

Array::Array(const Array& obj)
{
    mLength = obj.mLength;
    mSpace = new int[mLength];
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

int Array::length()
{
    return mLength;
}

Array::~Array()
{
    mLength = -1;
    delete[] mSpace;
}

int& Array::operator[](int i)
{
    return mSpace[i];
}

Array& Array::operator= (const Array& obj)	//obj右参数 
{
    delete[] mSpace;
    mLength = obj.mLength;
    mSpace = new int[mLength];
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
    return *this;
}

bool Array::operator== (const Array& obj)
{
    bool ret = true;
    if( mLength == obj.mLength )
    {
        for(int i=0; i<mLength; i++)
        {
            if( mSpace[i] != obj.mSpace[i] )
            {
                ret = false;
                break;
            }
        }
    }
    else
    {
        ret = false;
    }
    return ret;
}

bool Array::operator!= (const Array& obj)
{
    return !(*this == obj);
}

------/main.cpp

#include <stdio.h>
#include "Array.h"
int main()
{
    Array a1(10);
    Array a2(0);
    Array a3(0);
    if( a1 != a2 )
    {
        printf("a1 != a2\n");
    }
    for(int i=0; i<a1.length(); i++)
    {
        a1[i] = i + 1;	//本质a1.operator[](i)函数调用,作为左值，故必返回引用 
    }
    for(int i=0; i<a1.length(); i++)
    {
        printf("Element %d: %d\n", i, a1[i]);
    }
    a3 = a2 = a1;	//返回Array&，为支持链式赋值，等价a3=(a2.operator=(a1))
    if( a1 == a2 )
    {
        printf("a1 == a2\n");
    }
    for(int i=0; i<a2.length(); i++)
    {
        printf("Element %d: %d\n", i, a2[i]);
    }
    return 0;
}

编译器为每个类提供默认赋值操作符，其仅为简单值复制，类中存在指针成员变量时就需重载赋值操作符
++操作符只有一个操作数，其有前缀后缀区分，如何重载才能区分前置运算和后置运算？
通过一个占位参数来区分前置运算和后置运算

class Complex
{
    int a;
    int b;
public:
    Complex(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    Complex operator++ (int);
    Complex& operator++ ();
};
Complex Complex::operator++ (int)	//obj++效率低 
{
    Complex ret = *this; 
    a++;
    b++;  
    return ret;
}
Complex& Complex::operator++ ()		//++obj 
{
    ++a; 
    ++b;
    return *this;
}

int main(int argc, char *argv[])
{
    Complex c1(1, 2);
    c1++;
    ++c1;
    return EXIT_SUCCESS;
}

&&和||操作符技术上可重载，但最好别重载

class Test
{
    int i;
public:
    Test(int i)
    {
        this->i = i;
    }
    Test operator+ (const Test& obj)
    {
        Test ret(0);
        cout<<"Test operator+"<<endl;
        ret.i = i + obj.i;
        return ret;
    }
    bool operator&& (const Test& obj)
    {
        cout<<"bool operator&&"<<endl; 
        return this->i && obj.i;
    }
};

int main(int argc, char *argv[])
{
    Test t1 = 0;
    Test t2 = 1;
    if( t1 && (t1 + t2) )	//等价t1.operator&&(t1.operator+(t2)),故先打印... 
    {
        cout<<"World"<<endl;
    }
    return EXIT_SUCCESS;
}

&&和||是C++中非常特殊的操作符，其内置实现了短路规则，操作符重载是靠函数重载来完成的，操作数作为函数参数传递，故参数都会被求值，无法实现短路规则