C++类的赋值运算符=的重载,以及深拷贝和浅拷贝

 

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

在面向对象程序设计中，对象间的相互拷贝和赋值是经常进行的操作。 如果对象在申明的同时马上进行的初始化操作，则称之为拷贝运算。例如：

        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()

 {

             name = new char[1]; //These code is added By CR

       *name = '/0';

    }

    A(int id,char*t_name)

    {

    _id=id;

    name=new char[strlen(t_name)+1];

    strcpy(name,t_name);

    }

    private:

        char *name;

        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.username);

}  

A& A::operator=(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.username);

        return *this;    

}

//另外一种写法：

//void A::operator=(A &a)

//{

//        if(username!=NULL)

//            delete username;

//        _id=a._id;

//        username=new char[strlen(a.username)+1];

//        if(username!=NULL)

//        strcpy(username,a.username);

//}

其实，从上可以看出，赋值运算符和拷贝函数很相似。不过赋值函数最好有返回值（进行链式赋值），返回也最好是对象的引用（为什么不是对象本身呢？note2有讲解）， 而拷贝函数不需要返回任何。同时，赋值函数首先要释放掉对象自身的堆空间（如果需要的话），然后进行其他的operation.而拷贝函数不需要如此，因为对象此时还没有分配堆空间。