c++成员运算符重载和友元运算符重载的比较（以++，--运算符为例）

1、对双目运算符而言，成员运算符重载函数参数列表中含有一个参数，而友元运算符重载函数参数列表含有两个参数；对单目运算符而言，成员运算符重载函数参数列表中没有参数，而友元运算符重载函数参数列表含有一个参数。
2、双目运算符一班可以被重载为友元运算符和成员函数运算符，但是当一个整数与一个复数相加时，必须使用友元函数。
例：友元运算符重载函数实现一个复数与一个整数相加

#include<iostream>
using namespace std;
class complex
{
    public:
        complex(int r=0,int i=0);
        friend complex operator+(complex com,int a)//定义友元运算符重载函数，+左侧是类对象，右侧是函数 
        {
            return complex(com.real+a,com.imag);
        }
        friend complex operator+(int a,complex com)//定义友元运算符重载函数，+左侧是函数，右侧是类对象
        {
            return complex(a+com.real,com.imag);
        }
        void show();
        private:
            int real,imag;
};

void complex::show()
{
    cout<<"real="<<real<<" imag="<<imag<<endl;
}

complex::complex(int r,int i)
{
    real=r;
    imag=i;
}
int main()
{
    complex com1(12,34),com2,com3;
    com2=com1+27;
    com2.show();
    com3=12+com1;
    com3.show();
    return 0;
}

结果：
real=39 imag=34
real=24 imag=34
如果有成员函数运算符，整数不是类的对象
com2=com1+27,则编译为com2=com1.operator(100)
com2=12+com1,则编译为com2=100.operator(com1),错误，100无法调用成员运算符重载函数。
所以，当一个整数与一个复数相加时，只能使用友元运算符重载函数

运算符函数调用形式
习惯调用形式 友元 成员函数
a+b operator+(a,b) a.operator+(b)
-a operator-(a) a.operator-()
a++ operator++(a,0) a.operator++(0)
–a operator–(a) a.operator–();

使用成员函数以前缀和后缀方式重载运算符–

#include<iostream>
using namespace std;
class three
{
    public:
        three(int a=0,int b=0,int c=0);
        void print();
        three operator--();//声明自减运算符--重载成员函数（前缀方式） 
        three operator--(int);//声明自减运算符--重载成员函数（后缀方式）
        private:
        int x,y,z; 
};

three::three(int a,int b,int c)
{
    x=a;
    y=b;
    z=c;
}

void three::print()
{
    cout<<"x="<<x<<" y="<<y<<" z="<<z<<endl;
}

three three::operator--()
{
    --x;
    --y;
    --z;
    return *this;//返回自减后的当前对象 
 } 
three three::operator--(int)
{
    three temp(*this); 
    x--;
    y--;
    z--;
    return temp;
}

int main()
{
    three obj1(4,5,6),obj2,obj3(7,8,9),obj4;
    obj1.print();
    --obj1;
    obj1.print();
    obj2=obj1--;//obj2保存的是执行obj1--前的obj1值 
    obj2.print();
    obj1.print();
    cout<<endl;
    obj3.print();
    obj3.operator--();
    obj3.print();
    obj4=obj3.operator--(0);
    obj4.print();
    obj3.print();
    return 0;
}

结果：
x=4 y=5 z=6
x=3 y=4 z=5
x=3 y=4 z=5
x=2 y=3 z=4

x=7 y=8 z=9
x=6 y=7 z=8
x=6 y=7 z=8
x=5 y=6 z=7

重载后缀自增运算符时，多了一个int型参数，这个参数只是为了与前缀++运算符重载函数有所区别，定义时可以只写int

使用友元函数以前缀方式和后缀方式重载运算符++

#include<iostream>
using namespace std;
class three
{
    public:
        three(int a=0,int b=0,int c=0);
        void print();
        friend three operator++(three &op);//声明自加运算符++重载友元函数（前缀方式） 
        friend three operator++(three &op,int);//声明自加运算符++重载友元函数（后缀方式） 
        private:
            int x,y,z;
 };

 three::three(int a,int b,int c)
 {
    x=a;
    y=b;
    z=c;
 }

 void three::print()
 {
    cout<<"x="<<x<<" y="<<y<<" z="<<z<<endl;
 }

three operator++(three &op)
{
    ++op.x;
    ++op.y;
    ++op.z;
    return op;
}

three operator++(three &op,int)
{
    op.x++;
    op.y++;
    op.z++;
    return op;
}
int main()
{
    three obj1(4,5,6),obj2(7,8,9);
    obj1.print();
    ++obj1;
    obj1.print();
    obj1++;
    obj1.print();
    cout<<endl;
    obj2.print();
    operator++(obj2);//显示调用 
    obj2.print();
    operator++(obj2,0);
    obj2.print();
    return 0;

}

结果：
x=4 y=5 z=6
x=5 y=6 z=7
x=6 y=7 z=8

x=7 y=8 z=9
x=8 y=9 z=10
x=9 y=10 z=11

友元运算符重载函数没有this指针，所以不能用this指针所指的对象，应采用对象引用参数传递数据