+  　　- 　　*  　　/  　　 %  　　　 ^  　　 &  　　|  　 ~  
! 　　 = 　　<  　　>  　　 +=  　　　-=  　　*=  　 /=   %=  
^= 　　&=   |=  　 <<  　　>>  　　　<<= 　　>>=  　==   !=  
<= 　　>=   && 　　||  　　++  　　  --  　　,  　　->*   ->  
()  　[] 　 new   new[]   delete   delete[]

长度运算符sizeof
三目运算符:  ?:
成员选择符.
域解析运算符::
成员指针.*

例如：=结合性是从右向左
a=b=3;
先执行b=3,再执行a=b

+-*/等需要两个操作数
++   --等一个操作数
.....

class A
{
private:
    int op;
public:
    A(int a1) :op(a1)
    {
    }

    A& operator+(const A& a)    //二元运算符，第一数为this对象，第二个是a对象
    {
        A nonObj(this->op + a.op);
        return nonObj;    //返回匿名对象
    }

    void getInfo()
    {
        cout << "op:" << op << endl;
    }
};

void main()
{
    A a1(10);
    A a2(12);
    A a3 = a1 + a2;
    a3.getInfo();
    system("pause");
}

或者A& A::operator+(const A& a){}

class A
{
    friend A& operator+(const A& a, const A& b);　　//补充：默认访问修饰符为private
private:
    int op;
public:
    A(int a1) :op(a1)
    {
    }

    void getInfo()
    {
        cout << "op:" << op << endl;
    }
};

A& operator+(const A& a, const A& b)    //私有是对于类，友元函数可以使用类的所有成员，不管访问修饰符
{
    A nonObj(a.op + b.op);
    return nonObj;
}

void main()
{
    A a1(10);
    A a2(12);
    A a3 = a1 + a2;
    a3.getInfo();
    system("pause");
}

友元函数和成员函数操作运算符需要区分前置和后置（符号前后置）
前置 operator++()
++a
后置 operator++(int)    //int进行占位区分  后面多一个，为后置
a++

对<<或者>>重载
cout<<数
cin>>数
左操作都是ostream或者istream无法修改的类，
所以重载<<或者>>只能用全局友元函数

<<返回ostream类型
cout<<a<<b       //连续输出a b两个变量
>>返回istream类型
cin>>a>>b;        //连续输入两个变量到a b

class A
{
    friend ostream& operator<<(ostream& out, A& a);
    friend istream& operator>>(istream& in, A& a);
private:
    int op;
public:
    A(int a1) :op(a1)
    {
    }

    void getInfo()
    {
        cout << "op:" << op << endl;
    }
};

ostream& operator<<(ostream& out, A& a)
{
    out <<"overload<<:"<< a.op << endl;
    return out;
}

istream& operator>>(istream& in, A& a)
{
    in >> a.op;
    return in;
}

void main()
{
    A a(10);
    cout << a;

    cin >> a;
    cout << a;

    system("pause");
}

class A
{
    friend ostream& operator<<(ostream& out, A& a);
    friend istream& operator>>(istream& in, A& a);
private:
    int op;
    int *pArr;
public:
    A(int a1) :op(a1)
    {
        pArr = (int *)malloc(sizeof(int)*a1);
        for (int i = 0; i < a1;i++)
        {
            pArr[i] = i+5;
        }
    }

    void getInfo()
    {
        cout << "op:" << op << endl;
    }

    //赋值运算符
    A& operator=(const A& a1)
    {
        cout << "operator=" << endl;
        A nonObj(this->op + a1.op);
        return nonObj;
    }

    //数组下标运算符
    int& operator[](int i)
    {
        cout << "operator[]" << endl;
        return this->pArr[i];
    }

    ~A()
    {
        if (this->pArr != NULL)
            free(this->pArr);
    }
};

ostream& operator<<(ostream& out, A& a)
{
    out <<"overload<<:"<< a.op << endl;
    return out;
}

istream& operator>>(istream& in, A& a)
{
    in >> a.op;
    return in;
}

void main()
{
    A a(10);
    //A b = a;    是错误的，不会调用=重载操作符，是初始化操作
    A b(5);
    b = a;    //会调用=重载运算符
    cout << a[3];

    system("pause");
}

class Func
{
public:
    double operator()(double x, double y);    //第一个()是重载的符号
};

double Func::operator()(double x, double y)
{
    return x*x + y*y;
}

void main()
{
    Func func;    //调用默认构造函数
    double ret = func(3.0, 4.0);
    cout << ret << endl;
    system("pause");
}