C++本质：类的赋值运算符=的重载，以及深拷贝和浅拷贝

关键词：构造函数，浅拷贝，深拷贝，堆栈(stack)，堆heap，赋值运算符
摘要:
    在面向对象程序设计中，对象间的相互拷贝和赋值是常常进行的操做。
    若是对象在申明的同时立刻进行的初始化操做，则称之为拷贝运算。例如：
        class1 A("af"); class1 B=A;
     此时其实际调用的是B(A)这样的浅拷贝操做。
    若是对象在申明以后，在进行的赋值运算，咱们称之为赋值运算。例如：
        class1 A("af"); class1 B;
        B=A;

  此时实际调用的类的缺省赋值函数B.operator=(A);
        不论是浅拷贝仍是赋值运算，其都有缺省的定义。也就是说，即便咱们不overload这两种operation,仍然能够运行。
那么，咱们到底需不须要overload这两种operation 呢？
        答案就是：通常，咱们咱们须要手动编写析构函数的类，都须要overload 拷贝函数和赋值运算符。

        
 下面介绍类的赋值运算符
1.C++中对象的内存分配方式
        在C++中，对象的实例在编译的时候，就须要为其分配内存大小，所以，系统都是在stack上为其分配内存的。这一点和C#彻底不一样！千 万记住：在C#中，全部类都是reference type,要建立类的实体，必须经过new在heap上为其分配空间，同时返回在stack上指向其地址的reference.
        所以，在C++中，只要申明该实例，在程序编译后，就要为其分配相应的内存空间，至于实体内的各个域的值，就由其构造函数决定了。
    例如：

class A
{
public:
    A()
    {
    }
    A(int id,char *t_name)
    {
    _id=id;
    name=new char[strlen(t_name)+1];
    strcpy(name,t_name);
    }
    private:
        char *username;
        int _id;
}

int main()
{
A a(1,"herengang");
A b;
}

在程序编译以后，a和b在stack上都被分配相应的内存大小。只不过对象a的域都被初始化，而b则都为随机值。
其内存分配以下：


2. 缺省状况下的赋值运算符
    若是咱们执行如下：
    b=a;
        则其执行的是缺省定义的缺省的赋值运算。所谓缺省的赋值运算，是指对象中的全部位于stack中的域，进行相应的复制。可是，若是对象有位于heap上的域的话，其不会为拷贝对象分配heap上的空间，而只是指向相同的heap上的同一个地址。
        执行b=a这样的缺省的赋值运算后，其内存分配以下：

        所以，对于缺省的赋值运算，若是对象域内没有heap上的空间，其不会产生任何问题。可是，若是对象域内须要申请heap上的空间，那么在析构对象的时候，就会连续两次释放heap上的同一块内存区域，从而致使异常。

    ~A()
     {        
        delete name;
    }

3.解决办法--重载（overload)赋值运算符
        所以，对于对象的域在heap上分配内存的状况，咱们必须重载赋值运算符。当对象间进行拷贝的时候，咱们必须让不一样对象的成员域指向其不一样的heap地址--若是成员域属于heap的话。    
所以，重载赋值运算符后的代码以下：

class A
{
public:

    A()
    {
    }
    A(int id,char *t_name)
    {
        _id=id;
        name=new char[strlen(t_name)+1];
        strcpy(name,t_name);
    }
    
    A& operator =(A& a)
//注意：此处必定要返回对象的引用，不然返回后其值当即消失！
    {
            if(name!=NULL)
                delete name;
        this->_id=a._id;
        int len=strlen(a.name);
        name=new char[len+1];
        strcpy(name,a.name);
        return *this;
    }

    ~A()
    {
        cout<<"~destructor"<<endl;
        delete name;
    }

    int _id;
    char *name;
};

int main()
{
 A a(1,"herengang");
 A b;
 b=a;
}其内存分配以下：

这样，在对象a,b退出相应的做用域，其调用相应的析构函数，而后释放分别属于不一样heap空间的内存，程序正常结束。


references:
类的深拷贝函数的重载
    public class A
{
    public:
        ...
        A(A &a);//重载拷贝函数
        A& operator=(A &b);//重载赋值函数
        //或者 咱们也能够这样重载赋值运算符 void operator=(A &a);即不返回任何值。若是这样的话，他将不支持客户代买中的链式赋值 ，例如a=b=c will be prohibited!
    private:
        int _id;
        char *username;
}

A::A(A &a)
{
    _id=a._id;
    username=new char[strlen(a.username)+1];
    if(username!=NULL)
        strcpy(username,a.usernam);
}

A& A::operaton=(A &a)
{
        if(this==&a)//  问：什么须要判断这个条件？（不是必须，只是优化而已）。答案：提示：考虑a=a这样的操做。
            return *this;
        if(username!=NULL)
            delete username;
        _id=a._id;
        username=new char[strlen(a.username)+1];
        if(username!=NULL)
            strcpy(username,a.usernam);
        return *this;    
}
//另一种写法：
void A::operation=(A &a)
{
        if(username!=NULL)
            delete username;
        _id=a._id;
        username=new char[strlen(a.username)+1];
        if(username!=NULL)
            strcpy(username,a.usernam);
}

其实，从上能够看出，赋值运算符和拷贝函数很类似。只不过赋值函数最好有返回值（进行链式赋值），返回也最好是对象的引用（为何不是对象自己呢？note2有讲解）， 而拷贝函数不须要返回任何。同时，赋值函数首先要释放掉对象自身的堆空间（若是须要的话），而后进行其余的operation.而拷贝函数不须要如此，由于对象此时尚未分配堆空间。note1:
    不要按值向函数传递对象。若是对象有内部指针指向动态分配的堆内存，丝绝不要考虑把对象按值传递给函数，要按引用传递。并记住：若函数不能改变参数对象的状态和目标对象的状态，则要使用const修饰符 

note2:问题：
    对于类的成员须要动态申请堆空间的类的对象，你们都知道，咱们都最好要overload其赋值函数和拷贝函数。拷贝构造函数是没有任何返回类型 的，这点毋庸置疑。 而赋值函数能够返回多种类型，例如以上讲的void,类自己class1，以及类的引用 class &? 问，这几种赋值函数的返回各有什么异同？
    答：1 若是赋值函数返回的是void ，咱们知道，其惟一一点须要注意的是，其不支持链式赋值运算，即a=b=c这样是不容许的！
          2 对于返回的是类对象自己，仍是类对象的引用，其有着本质的区别！
              第一：若是其返回的是类对象自己。
   A operator =(A& a)
     {
            if(name!=NULL)
                delete name;
        this->_id=a._id;
        int len=strlen(a.name);
       name=new char[len+1];
        strcpy(name,a.name);
        return *this;
    }
          其过程是这样的：
                       class1 A("herengnag");
                        class1 B;   
                        B=A;
                    看似简单的赋值操做，其全部的过程以下：
                       1 释放对象原来的堆资源
                       2 从新申请堆空间
                       3 拷贝源的值到对象的堆空间的值
                       4 建立临时对象（调用临时对象拷贝构造函数），将临时对象返回
                       5. 临时对象结束，调用临时对象析构函数，释放临时对象堆内存
my god,还真复杂！！
            可是，在这些步骤里面，若是第4步，咱们没有overload 拷贝函数，也就是没有进行深拷贝。那么在进行第5步释放临时对象的heap 空间时，将释放掉的是和目标对象同一块的heap空间。这样当目标对象B做用域结束调用析构函数时，就会产生错误！！
            所以，若是赋值运算符返回的是类对象自己，那么必定要overload 类的拷贝函数（进行深拷贝）！
            第二：若是赋值运算符返回的是对象的引用，
   A& operator =(A& a)
    {
            if(name!=NULL)
                delete name;
        this->_id=a._id;
        int len=strlen(a.name);
       name=new char[len+1];
        strcpy(name,a.name);
        return *this;
    }
        那么其过程以下：
                   1 释放掉原来对象所占有的堆空间
                   1.申请一块新的堆内存
                   2 将源对象的堆内存的值copy给新的堆内存
                   3 返回源对象的引用
                    4 结束。
    所以，若是赋值运算符返回的是对象引用，那么其不会调用类的拷贝构造函数，这是问题的关键所在！！
 
完整代码以下：

// virtual.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "string.h"
#include "stdlib.h"
#include "assert.h"

class complex
{
public:
        int real;
        int virt;
public:
    complex(){real=virt=0;}
    complex(int treal,int tvirt){real=treal;virt=tvirt;}
    complex operator+(const complex &x)
    {
        real+=x.real;
        virt+=x.virt;
        return *this;
    }
    complex operator=(const complex &x)
    {
        return complex(x.real,x.virt);
    }
};


class A
{
public:
    A(){m_username=NULL;printf("null constructor");}
    A(char *username)
    {
        int len;
        len=strlen(username);
        m_username=new char[len+1];//(char*)malloc(sizeof(len+1));
        strcpy(m_username,username);
        printf(""nUsername is %s"n",m_username);
    }
    
    A(A &a);
    A operator=(A &b);
    int test(const int &x)
    {
        return x;
    }

    virtual ~A()
    {
    //    if(m_username)
        {
        delete m_username;
        printf(""nA is destructed"n");
        }
    }



protected:
    char *m_username;

};



A::A(A &a)
{

    int len=strlen(a.m_username);
    this->m_username=new char[len+2];
    strcpy(m_username,a.m_username);
    strcat(m_username,"f");
    printf(""ndeep copy function");
}


A A::operator=(A &b)
{
    if(m_username)
        delete m_username;

    int len=strlen(b.m_username);
    this->m_username=new char[len+1];
    strcpy(m_username,b.m_username);
//    printf("copied successfully!");
     return *this;
}

 

class B:public A
{
public:
    B(char *username,char *password):A(username)
    {
        int len=strlen(password)+1;
        m_password=new char[len];//(char *)malloc(sizeof(len));
        strcpy(m_password,password);
        printf("username:%s,password:%s"n",m_username,m_password);
    }
    ~B()
    {
        delete m_password;
        printf("B is destructed"n");
    }
protected:
    char *m_password;
};

int main(int argc, char* argv[])
{
//    B b("herengang","982135");
//    A *a=&b;
//    delete a;
    A a("haha");
    A b;

    printf(""nbegin to invoke copy function");
    b=a;

//    printf("%d",b.test(2));
    //complex x(1,3),y(1,4);
    //x=(x+y);
    //printf("%d,%d",x.real,x.virt);
    return 0;


}

1 重载赋值运算符返回结果为类对象的运行结果

明显， 运算符最后调用了拷贝构造函数

2 重载赋值运算符返回结果为类对象引用的运行结果

很明显，没有调用拷贝构造函数

转自：http://www.cnblogs.com/alexusli/archive/2008/08/27/1277683.html