C++重载赋值运算符使用方法

赋值运算符可能是最容易令人迷惑的一个，所以，重载它必须十分的小心。
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”<    //没有检测自赋值情况
    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”<//检测自赋值情况
if(this != &a)
{
delete []p;
        p = a.p;
    a.p = NULL;
}
return *this;
};
正因为在自赋值的情况下可能给对象造成伤害，所以在重载赋值运算符时必须要注意自赋值的情况。所谓习惯成自然，如果我们养成良好的习惯，我们就会避免犯种种错误。

所以integer类中的赋值运算符函数应写成这样：
integer& integer::operator=(const integer& a)
{
    if(this != &a)

[NextPage]

    i = a.i;
return *this;
};

3.为什么赋值运算符没有调用？

现在，我们的CA类拥有一个“完美”的赋值运算符函数，现在让我们坐下来，写下这样一段代码（例子代码2），并等着它打印出operator = invoked：
[Page]
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\"<        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\"<    p = NULL;
};

~CA()
{
    cout<<\"destructor\"<    delete []p;
};
……
};
执行例子代码1，结果为：
constructor           //a1的构造函数
constructor           //a2的构造函数
operator= invoked     //赋值语句
copy constructor      //临时变量的拷贝构造函数
destructor            //临时变量被析构
destructor            //a2被析构
destructor           //a1被析构
临时变量产生、调用拷贝构造函数、然后被析构，不知你是否清楚的意识道这到底意味着什么：当我们调用a2 = a1;时，a1“拥有”的内存被转交给a2，然后又被转交给了那个临时变量，最后，当临时变量析构时被释放！这当然不是我们想要的，还是乖乖的把赋值运算符函数的返回值类型定义为CA&吧。

[NextPage]

4.     自动创建的赋值运算符
现在想一下，如果我们不定义CA中的赋值运算符会发生什么事，难道例子代码1中的 a2 = a1会引起一个编译错误吗？当然不会，编译器将为我们自动创建一个。这个运算符行为模仿自动创建的拷贝构造函数：如果类包含对象（或是从其他类继承下来的），对应这些对象，运算符‘=’被递归调用，这称为成员赋值。