重载赋值运算符

  重载赋值运算符

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

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