在加法重载时,比如c1=c2+c3; 自己写的=重载,为什么有的形参需要const(不写会错)，而有的不需要(对同样类型)

是对于同样地类型，类
 A operator +(const A& c)
{     //;;   }
类
B operator+(B& b)
{    //,,,,,,}
第二个不用const可以，但是第一个必须要有请那个高手回答一下，就当帮小弟一个忙，谢谢

加const主要是针对另一个操作数是常对象/常量的情况。c++出于数据安全考虑，支持上述两种重载，加const的适用于常量和非常量，但是常对象必须要匹配加const的重载。

第一个和第二个不是一样么。。B 和 A 是什么关系？派生类吗？

两个是类型一样的类，没有关系，第一个是c1=c2+c3中调用=重载时必须引用加const，不加就会错，而第二个程序中，如 d1=d2+d3,的时候直接用引用不加const也是对的，我就感觉同样的类型，同样的=重载，怎么一个对，一个错呢（两个类是两个函数中的）

列如:
class Complex
{
    int real,image;
    public:
        Complex(real=0,image=0):real(real),image(image){}
    Complex operator +(complex& b)
    {   
        Complex t;
        t.real=real+b.real;
        t.image=image+b.image;
    return t;
    }
    void operator =(Complex& c)
    {
        real=c.real;
        image=c.image;
    }
void show(int i)
{
    cout<<"c"<<i<<"="<<real<<"+"<<image<<"i"<<endl;
}
};

int main()
{
    Complex c1(10,20),c2(12,24),c3;
    c3=c1+c2;
    c3.show(3);
}

class F//n为分子，f为分母
{
    int n,f;
    public:
        F(int n=0,int  f=1):n(n),f(f){}
    F operator+(F& c)
    {
        F t;
        t.n=n*c.f+c.n*n;
        t.f=f*c.f;
           return t;
    }
    friend ostream& operator<<(ostream& o,const F& f)
    {
        o<<f.n<<"/"<<f.f;
        return o;
    }
    void operator =(F& c)
    {
        n=c.n;
        f=c.f;
    }
};

int main()
{
    F c1(1,2),c2(2,3),c3;
    c3=c1+c2;
    cout<<"c3="<<c3<<endl;
}

这两个程序我感觉一样啊，为什么第一个会错，第二个没错，当第一个在=重载的时候的形参加const就对了（const Complex& c）

[ 本帖最后由 chinawide 于 2013-1-22 13:06 编辑 ]

就是这个问题吧，去看看：
https://bbs.bccn.net/thread-397244-1-1.html

你刚才说的有的懂了，但是对于上面的例子里都没有cv限制吧。你可以对于上面的例子分析一下吗 ？
 谢谢你

你的程序有不少小语法错误呢，建议你先自己改改。

自己写的=重载,为什么有的形参需要const(不写会错)，而有的不需要(对同样类型)。。对这句话 LZ贴个示例而来分析、 另外你贴的那个程序 有什么错误你是否知道。最后能说出来

实在不好意思，刚才太急，有很多错误
class Complex
{
    int real,image;
    public:
        Complex(real=0,image=0):real(real),image(image){}
    Complex operator +(complex& b)
    {   
        Complex t;
        t.real=real+b.real;
        t.image=image+b.image;
    return t;
    }
   
    Complex& operator =(Complex& c)
    {
        real=c.real;
        image=c.image;
    }
void show(int i)
{
    cout<<"c"<<i<<"="<<real<<"+"<<image<<"i"<<endl;
}
};

int main()
{
    Complex c1(10,20),c2(12,24),c3;
    c3=c1+c2;
    c3.show(3);
}

class F//n为分子，f为分母
{
    int n;
    int d;
    public:
        F(int n=0,int d=1):n(n),d(d){}
    F operator+(F& c)
    {
        F t;
        t.n=n*c.d+d*c.n;
        t.d=d*c.d;
           return t;
    }
    friend ostream& operator<<(ostream& o,const F& f)
    {
        o<<f.n<<"/"<<f.d        
           return o;
    }
    F& operator =(F& c)
    {
        n=c.n;
        d=c.d;
    }
};

int main()
{
    F c1(1,2),c2(2,3),c3;
    c3=c1+c2;
    cout<<"c3="<<c3<<endl;
}

为什么第一个会错，第二个没错，当第一个在=重载的时候的形参加const就对了（const Complex& c）

[ 本帖最后由 chinawide 于 2013-1-22 13:03 编辑 ]