重载赋值运算符

  重载赋值运算符
赋值运算符可能是最容易令人迷惑的一个,所以,重载它必须十分的小心。
1. 值运算符仅能重载为成员函数。
C++不允许赋值运算符被重载为全局形式,这是因为如果可以写出全局形式的赋值运算符函数的话,我们可以写出这样的函数:
 iint operator=(int a, integer b);
从而出现这样无法无天的语句:
integer a(3);
2 = a;//God save me
2. 注意自赋值的情况
现在我们写一个简单的 integer类并重载赋值运算符。
 class integer
{
int i;
public:
integer(int j):i(j){};
    integer& operator=(const integer& a)
{
    i = a.i;
    return *this;
   };
 };
嗯,不错。但,且慢,你没有考虑自赋值的情况。啊,有必要吗?的确,在这个例子中找不到检测自赋值的理由,但请看下面这个例子 :
class CA
{
public:
char* p;
   CA(){p = NULL;};
void Set(char* pStr)
{
    delete []p;
if(pStr == NULL)
{
         p = NULL;
}
else
{
p = new char[strlen(pStr)+1];
        strcpy(p, pStr);
}
 };
    CA& operator=(CA& a)
{
cout<<” operator = invoked/n”<<endl;
    //没有检测自赋值情况
    delete []p;
    p = a.p;
   a.p = NULL;
   return *this;
};
    ~CA(){delete []p;};
}; 
CA对象“拥有”它成员p指向的内存。所以,在赋值函数中,参数a将放弃 它的“拥有权”,并将它转交给调用对象。(C++标志库中定义的智能指针auto_ptr就是一种“拥有”型智能指针,它也存在这种“拥有权转移”的性质)
请见下面的例子代码(例子代码 1):
CA a1, a2;
a1.Set(“Ok”);
a2 = a1;
我们的函数看起来工作的很好,但是,请看下面一条语句:
a2 = a2;// 悲剧发生了,a2“拥有”的内存被释放了!
所以,赋值运算符函数应写为下面的形式:
CA& CA::operator=(CA& a)
{
   cout<< ” operator = invoked/n”<<endl;
//检测自赋值情况
if(this != &a)
{
delete []p;
        p = a.p;
    a.p = NULL;
}
return *this;
};
正因为在自赋值的情况下可能给对象造成伤害,所以在重载赋值运算符时必须要注意自赋值的情况。所谓习惯成自然,如果我们养成良好的习惯,我们就会避免犯种种错误。
 
所以 integer类中的赋值运算符函数应写成这样:
integer& integer::operator=(const integer& a)
{   
    if(this != &a)
    i = a.i;
return *this;
};
 
3.为什么赋值运算符没有调用?
 
现在,我们的 CA类拥有一个“完美”的赋值运算符函数,现在让我们坐下来,写下这样一段代码(例子代码2),并等着它打印出operator = invoked:
CA a1;
a1.Set(” Ok”);
CA a2 = a1;
可是 ……
天哪,我们的程序崩溃了。
调试证明,这段代码根本没有调用赋值运算符函数 ,why?
如果你仔细地检查例子代码 1和2,你会发现他们之间的差别仅仅在于: 代码2中a2定义时就被初始化为a1的值……
等等,你想到什么了吗,没错,就是它:拷贝构造函数。C++保证对象都会被初始化,所以CA a2 = a1;不会调用赋值运算符 而是 会调用拷贝构造函数。因为类中没有定义拷贝构造函数,所以编译器就会生成一个缺省的拷贝构造函数。而这个函数仅仅是简单的bitcopy,a1“拥有”的内存并没有转交给a2,这样,那块内存被两个对象所“拥有”,当对象析构时,它被delete了两次,于是悲剧发生了。
所以,我们需要定义自己的拷贝构造函数:
class CA
{
public:
    CA(CA& a)
   {
        cout<<"copy constructor"<<endl;
        p = a.p;
        a.p = NULL;
    }
……
};
因为函数中将改变参数,所以参数不能定义为 const的。
现在无论执行代码 1还是代码2都不会有什么问题。
在这部分结束之前,我再问你一个问题:如果我们将赋值运算符函数的返回值类型由 CA& 改为 CA 会发生什么呢?
好,让我们执行例子代码 1看看结果:
operator= invoked
copy constructor //这一句话怎么来的
嗯,没错,赋值运算符函数被调用了。但,为什么还会调用拷贝构造函数呢?
将代码1中的a2 = a1;用函数形式代替,将帮助我们找到答案:
a2 = a1; 相当于a2.operator=(a1); 而函数operator=将返回一个CA对象,于是编译器产生一个临时变量,并调用拷贝构造函数对它进行初始化。而随后,这个对象被摧毁,析构函数被调用。现在,让我们给CA的构造和析构函数都加上打印语句,我们就会清楚的看到这个过程。
class CA
{
public:
int *p;
CA()
{
cout<<"constructor"<<endl;
    p = NULL;
};
 
~CA()
{
    cout<<"destructor"<<endl;
    delete []p;
};
……
};
执行例子代码 1,结果为:
constructor            //a1的构造函数
constructor            //a2的构造函数
operator= invoked      //赋值语句
copy constructor       //临时变量的拷贝构造函数
destructor             //临时变量被析构
destructor             //a2被析构
destructor           //a1被析构
临时变量产生、调用拷贝构造函数、然后被析构,不知你是否清楚的意识道这到底意味着什么:当我们调用a2 = a1;时,a1“拥有”的内存被转交给a2,然后又被转交给了那个临时变量,最后,当临时变量析构时被释放!这当然不是我们想要的,还是乖乖的把赋值运算符函数的返回值类型定义为CA&吧。
  
4.      自动创建的赋值运算符
现在想一下,如果我们不定义CA中的赋值运算符会发生什么事,难道例子代码1中的 a2 = a1会引起一个编译错误吗?当然不会,编译器将为我们自动创建一个。这个运算符行为模仿自动创建的拷贝构造函数:如果类包含对象(或是从其他类继承下来的),对应这些对象,运算符‘=’被递归调用,这称为成员赋值。对于这一问题的详细讨论,请见《C++编程思想》第一版,第11章(p225)。
 
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值