CSDN博客

img zcs001

重载赋值运算符

发表于2003/11/27 0:39:00  2780人阅读

                              重载赋值运算符

赋值运算符可能是最容易令人迷惑的一个,所以,重载它必须十分的小心。

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)。

 

 

0 0

相关博文

我的热门文章

img
取 消
img