c++ 运算符重载

/*在类中重载运算符只能重载一元的，即只接受一个参数，调用者为对象，而如果要重载二元运算符，则应该在类外定义，
 并且声明为类的友元函数，这样，这个函数在类外定义时不用使用作用域符，因为它不属于类，但是因为是友元函数，所以
 和类的公有函数具有同样的权限 */
 //在类中重载运算符然后在类外使用时的本质：如 两个对象相加 ，c=a+b; 本质是  c=a.operator+(b);也就是说运算符左侧应该是对象，
 //但是如果我们是:c=3+a;左侧不是调用对象，所以这就限定了在类中重载运算符时，重载运算符定义函数只能接受一个参数，
 //而非成员函数它所用的都是显式参数，可以接受两个，所以我们需要友元函数。 另外，友元函数虽然是在类中声明的，但它不是类成员函数
 //因此不能对友元函数用成员运算符来调用
#include<iostream>
using namespace std;
class oo
{
    public:
        void output();
        void input();
        oo();
        oo(int c,double d);
        oo operator+(const oo & t) const;
        friend oo operator*(double m,const oo & t);
        friend oo operator*(const oo & t,double m);
        friend oo operator*(int m,const oo & t); //当定义接受两个参数的运算符重载友元函数，之后使用运算符将会自动将第一个参数
        //当成运算符左边的数值
        friend oo operator*(const oo & t,int m);//声明友元函数
        friend ostream & operator<<(ostream & os,const oo & t);//重载输入输出流运算符，需要接受一个ostream类对象：cout的引用，
        //cout对象的实际运行过程是在输出要输出的东西后还会返回一个cout对象，以此来输出后面的内容，所以我们重载的时候也要返回一
        //对象，或者说返回一个对象的引用
    private:
        int a;
        double b;
//        double c;        
};
ostream & operator<<(ostream & os,const oo & t)
{
    os<<"a= "<<t.a<<" "<<"b="<<t.b<<endl;
    return os;
}        

oo oo::operator+(const oo & t) const
{
    oo shu;
    shu.a = a + t.a;
    shu.b = b + t.b;
    return shu;
}//运算符重载，将两个类中的数据相加，返回一个对象 ,不返回对象的引用是因为要返回的对象是在函数中创建的，当函数调用完后会被释放，到时候就是
//一个空的引用
oo operator*(double m,const oo & t)
{
    oo shu;
    shu.b = m*t.b;
    return shu;
}//类外定义两个参数的运算符重载，实数乘以对象
oo operator*(const oo & t,double m)
{
    oo shu;
    shu.b = m*t.b;
    return shu;
}//运算符重载，对象乘以实数
oo operator*(int m,const oo & t)
{
    oo shu;
    shu.a = m*t.a;
    return shu;
}//整数乘以对象
oo operator*(const oo & t,int m)
{
    oo shu;
    shu.a = t.a*m;
    return shu;
}//对象乘以整数
void oo::input()
{
    int j;
    double k;
    cin>>j>>k;
    a = j;
    b = k;
}
void oo::output()
{
    cout<<"a= "<<a<<" "<<"b="<<b<<endl;
}
oo::oo()
{
    a = 100;
    b = 100.001;
}
oo::oo(int c,double d)
{
    a = c;
    b = d;
}
int main()
{
    oo n;
    oo m = oo(55,55.55);
    oo *p = new oo(66,66.66);
    oo u(88,88.88);
    n.output();
    m.output();
    p->output();
    u.output();    
    oo z;
    z = n + m;
    z.output();
    oo h;
    h = n + m + u;
    h.output();
    oo j;
    j.output();
    j = 3.7*h;
    j.output();
    j = 5*j;
    j.output();//因为在运算符重载的定义里面是重新声明一个对象，所以这里运行结果看起来会像刷新了一样
    j = j*5.5;
//    j.output();
    cout<<j<<"################";
    
    return 0;
 }