拷贝构造函数 和 赋值函数

http://www.cnblogs.com/lionfight/archive/2012/05/25/2518631.html

 

 

 

什么时候用拷贝构造函数，和赋值构造函数：
（一）当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化。
    如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。
    自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。
例子：
String a("hello");
String b("world");
String c = a; // 调用了拷贝构造函数，最好写成 c(a);
c = b; // 调用了赋值构造函数。！
本例中第三个语句的风格较差，宜改写成String c(a) 以区别于第四个语句。
（二）拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。
不同点：
拷贝构造函数首先是一个构造函数，它调用的时候产生一个对象，是通过参数传进来的那个对象来初始化，产生的对象。 
operator=();是把一个对象赋值给一个原有的对象，所以如果原来的对象中有内存分配要先把内存释放掉，而且还要检查一下两个对象是不是同一个对象，如果是的话就不做任何操作。
还要注意的是拷贝构造函数是构造函数，不返回值；而赋值函数需要返回一个对象自身的引用，以便赋值之后的操作。

浅拷贝和深拷贝
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
    深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。
    浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

下面是例子，注意看两种函数怎么写，什么地方用到：

#include <iostream>

using namespace std;

class CA

{

  public:

    CA(int b,char* cstr)

    {

      a=b;

      str=new char[b];

      strcpy(str,cstr);

    }

    CA(const CA& Other)                    //拷贝构造函数

    {

      a=Other.a;

      str=new char[a]; //深拷贝

      if(str!=0)

        strcpy(str,Other.str);

    }

    CA & operator = (const CA& Other)    //赋值符重载

    {

        a=Other.a;    //复制常规成员

        // (1) 检查自赋值

        if(this == &Other)

        return *this;

        // (2) 释放原有的内存资源

        delete [] str;

        // (3) 分配新的内存资源，并复制内容

        str = new char[a];

        strcpy(str,Other.str);

        // (4) 返回本对象的引用

        return *this;

    }

    void Show()

    {

      cout<<str<<endl;

    }

    ~CA()

    {

      delete str;

    }

  private:

    int a;

    char *str;

};

int main()

{

  CA A(10,"Hello!");

  CA B=A;

  B.Show();

  CA C(9,"world!");

  C = B;

  return 0;

} 

下面是另外一个例子，修改了下里面的赋值构造函数，把temp变量去掉了，这样更省空间吧？

class CExample

{

    ...

    CExample(const CExample&); //拷贝构造函数

    CExample& operator = (const CExample&); //赋值符重载

    ...

};

//拷贝构造函数使用赋值运算符重载的代码。

CExample::CExample(const CExample& RightSides)

{

    pBuffer=NULL;

    *this=RightSides     //调用重载后的"="

}

//赋值操作符重载

CExample & CExample::operator = (const CExample& RightSides)

{

    nSize=RightSides.nSize; //复制常规成员

    char *temp=new char[nSize]; //复制指针指向的内容 

    memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

    delete []pBuffer; //删除原指针指向内容  (将删除操作放在后面，避免X=X特殊情况下，内容的丢失)

    pBuffer=temp;   //建立新指向

    return *this

}

//其实也没啥改进，但觉得这样的写法是不是更好？省了一个temp临时变量。

CExample & CExample::operator = (const CExample& RightSides)

{

    nSize=RightSides.nSize; //复制常规成员

    delete []pBuffer; //删除原指针指向内容  (将删除操作放在后面，避免X=X特殊情况下，内容的丢失)

    pBuffer=new char[nSize];   //建立新指向

    memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));

    return *this

}