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。