c++中赋值操作符的重载

  直接抛问题，两个同类型的对象可以相互赋值？

class cls
{
public:
int a;
char c;

cls() : a(10), c('g')
{}

cls(int a, char c) : a(a), c(c)
{}

};

int main(void)
{
cls c1(6, 's');

cls c2;

c2 = c1;

printf("c2.a = %d, c2.c = %c\n", c2.a, c2.c);

return 0;
}

  编译运行：



  显然c++支持两个同类型的对象可以相互赋值的。

  ”c2 = c1;”注意要跟”cls c2 = c1;”区分开，前者是赋值语句，后者是初始化。对于后者，对象c2会调用类的拷贝构造函数，实现将c1到c2的拷贝。关于拷贝构造函数的使用，在前面http://blog.csdn.net/qq_29344757/article/details/76037255一文中有详细介绍。

  两个同类型的对象可以直接使用”=”(赋值操作符)进行赋值，其实这是类已经实现对赋值操作符的重载。但是在上面的代码中，我们并没有定义赋值操作符重载函数，可见，c++类会默认为我们定义。

  综合前面所学习的可知，一个空的c++类：

class cls
{
};

  编译器会为我们默认定义构造函数、拷贝构造函数、析构函数以及赋值操作符重载函数，也就变成：

class cls
{
public:
cls();
~cls();
cls(const cls& c);
cls& operator= ();
};

  那么问题出现，默认的赋值操作符重载函数内部实现的深度拷贝还是浅拷贝？

class cls
{
public:
int a;
int *p;

cls()
{
p = new int(0);
a = 0;
}

cls(int a, int b)
{
p = new int(b);
this->a = a;
}

~cls()
{
delete p;
}
};

int main(void)
{
cls c1(6, 7);
cls c2;

c2 = c1;    //调用默认的赋值运算符重载函数

printf("c2.a = %d, *c2.p = %d\n", c2.a, *c2.p);

return 0;
}

  编译运行：



  堆栈出错，提示重复释放内存。

  显然，跟默认拷贝构造一个样，默认的赋值运算符重载函数也是浅拷贝，所以指针变量c2.p和c1.p是一样的。我们需要自定义赋值运算符重载函数(顺便把拷贝构造函数也自定义)：

class cls
{
public:
int a;
int *p;

cls()
{
p = new int(0);
a = 0;
}

cls(int a, int b)
{
p = new int(b);
this->a = a;
}

//自定义拷贝构造函数
cls(const cls& c)
{
p = new int(*c.p);
}

//自定义赋值运算符重载函数
cls& operator= (const cls& c)
{
if (this == &c)
return *this;

delete p;
p = NULL;

p = new int(*c.p);

return *this;
}

~cls()
{
delete p;
}
};

int main(void)
{
cls c1(6, 7);
cls c2;

c2 = c1;        //调用了cls& operator= (const cls& c)

printf("c1.p = %p, c2.p = %p\n", c1.p, c2.p);

printf("c2.a = %d, *c2.p = %d\n", c2.a, *c2.p);

return 0;
}

编译运行正常：



下来仔细看看自定义的操作符重载函数：

cls& operator= (const cls& c)
{
if (this == &c)
return *this;

delete p;
p = NULL;

p = new int(*c.p);

return *this;
}

(1) 参数const cls& c：加上const原因在于我们不希望此函数对用来进行赋值的c做任何修改，其次有加上const的形参，能接受const和非const的实参，反之只能接收非const的实参

(2) 返回值cls&：返回值是返回被赋值着的引用，即*this，这样可以实现连续赋值，即类似于：

x = y = z;

若不是返回引用”cls& “而是直接是”cls”，那返回的是(*this)的副本，再用这个副本做左值，那么就出错了。

(3)避免自赋值：c/c++的语法并不反对类似”a = a”这样的自赋值语法，所以要在操作符重载加以判断避免自赋值操作，一来为了提高效率，二来避免出错。假设如上代码去掉if判断：

cls& operator= (const cls& c)
{
delete p;
p = NULL;

p = new int(*c.p);

return *this;
}

而*this跟参数c是同一个对象，那么在执行”delete p;”后也就意味着c.p也被delete了，那执行到”p = new int(*c.p);”就出错了，因为被delete后的p已经是一个野指针，对一个野指针解引用就会Segmentation fault。

(4)为什么要先”delete p;”再执行new

因为原先的p是通过类的构造函数new的，要再new一个空间并初始化为(*c.p)就需要先将原来p给delete，不然将造成内存泄漏。其实在这里可以复用p原型的堆空间，那么代码将改成：

cls& operator= (const cls& c)
{
if (this == &c)
return *this;

*p = *c.p;      //这也是深度拷贝

return *this;
}

这样改成反而看着简单。

(6)赋值运算符的重载函数只能是类的成员函数，不能是是类的静态函数(因为静态成员函数只能操作类的静态成员)，也不能是(友元)全局函数，否则在编译阶段就出错了！假设可以为全局函数，c++类已经默认提供了赋值重载函数了，那么在赋值运算符重载函数(全局函数)和赋值运算符重载函数(类的成员函数)同时存在的情况下，当进行相同类型间的赋值时，编译器就不知道要调用哪一个函数了。再者，假设可以用全局函数重载赋值操作符：

int operator= (int a, cls& c)
{
//...
}

int main(void)
{
cls c(5);

6 = c;      //哥们，这就有点过分了

return 0;
}

(7) 调用的时机

对比拷贝构造函数和赋值运算符重载函数的代码，可见除了避免自赋值判断之外，赋值运算符重载函数还比拷贝构造函数多了一句delete。一开始我很纳闷，想不出为何，其实那是我忽略了初始化和赋值这两个小玩意。初始化调用的是拷贝构造函数，”p = new int(*c.p);”语句是对象首次动态分配空间中边分配边为该空间初始化的，但是在赋值时调用的是赋值运算符重载函数，”p = newint(*c.p);”是在第二次分配空间的时候变分配边为该空间初始化的，所以需要把上次的new到的空间delete。