C++ 类的拷贝(或复制)和赋值

类的拷贝(复制)针对从无到有新创建的对象，类赋值是针对已存在的对象。

C++ 类的拷贝(或复制)
举例：Box box1(box2) 或者 Box box1=box2; (对象box2之前已经定义);

拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量。
在自己未主动定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数("位拷贝")——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。
但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。

深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。
简而言之，当数据成员中有指针时，必须要用深拷贝
以类 String 的两个对象 a, b 为例，假设 a.m_data 的内容为“hello”，b.m_data 的内容为“world”。现将 a 赋给b，缺省赋值函数的“位拷贝”意味着执行 b.m_data = a.m_data。这将造成三个错误：一是 b.m_data 原有的内存没被释放，造成内存泄露；二是 b.m_data 和 a.m_data 指向同一块内存，a 或 b 任何一方变动都会影响另一方；三是在对象被析构时，m_data
被释放了两次。

例一：拷贝构造函数

#include <iostream>  
  
using namespace std;  
class A{  
private:  
    int num;  
public:  
    A(){  
       cout<<"这是默认构造函数"<<endl;  
       }  
    A(const A &a){  
     cout<<"这是拷贝构造函数"<<endl;  
    }  
    A& operator=(const A &a){  
     cout<<"这是赋值重载"<<endl;  
     return *this;  
    }  
};  
void main(){  
  A a;    // 调用默认构造函数
  A b(a); // 调用拷贝构造函数 
  A c=b;  // 调用拷贝构造函数
  c=a;    // 调用重载的赋值运算符
}

例二：带有指针的深拷贝

#include <iostream>
#include <cstring>
using namespace std;

class CExample
{
private:
    int _num;
    char * _str;
public:
    //普通构造函数
    CExample(int b,char *str):_num(b){
     _str=new char;
     strcpy(_str,str);
    }

    //拷贝构造函数
    CExample(const CExample & C){
    _num=C._num;
    _str=new char[_num];
        if(_str!=0){
        strcpy(_str,C._str);
        }
    }

    ~CExample(){
    delete _str;
    }

    void Show(){
    cout<<_num<<" "<<_str<<endl;
    }
};

int main()
{
    CExample A(10, "hello");
    CExample B=A;
    A.Show();
    //A.Show();
    B.Show();
 return 0;
}

[b]C++ 类的赋值

举例：Box box1(1, 2, 3), box2(4, 5, 6); box1 = box2;

函数返回值声明为该类型引用，并在函数结束前返回实例自身引用即（*this） ，只有返回引用才能进行连续赋值
传入参数类型为常量引用，如果传递是实例，会调用一次复制构造函数，减少消耗，提高效率，加上const不会改变传入实例值
释放实例本身已有内存，避免造成内存泄露
判断传入实例和当前实例是否相同，相同返回，否则直接进行赋值，一旦释放自身内存，传入参数内存也被释放了

举例：

#include <stdio.h>
#include <cstring>

class CMyString
{
public:

    CMyString(char* pData = NULL);    //默认值为空
    CMyString(const CMyString& str);  //声明拷贝构造函数
    ~CMyString(void);
    CMyString& operator = (const CMyString& str);  //重载=号

    void Print();

private:
    char* m_pData;
};

CMyString::CMyString(char *pData)  //定义时没有默认值
{
    if(pData == NULL)
    {
        m_pData = new char[1];
        m_pData[0] = '\0';
    }
    else
    {
        int length = strlen(pData);
        m_pData = new char[length + 1];
        strcpy(m_pData, pData);
    }
}

CMyString::CMyString(const CMyString &str)
{
    int length = strlen(str.m_pData);
    m_pData = new char[length + 1];
    strcpy(m_pData, str.m_pData);
}

CMyString::~CMyString()
{
    delete[] m_pData;
}

CMyString& CMyString::operator = (const CMyString& str)
{
    if(this == &str)  //判断是否值同一个示例
        return *this;

    delete []m_pData;  //删除原有示例，避免内存泄露
    m_pData = NULL;

    m_pData = new char[strlen(str.m_pData) + 1];
    strcpy(m_pData, str.m_pData);

    return *this;
}

// ====================测试代码====================
void CMyString::Print()
{
    printf("%s", m_pData);
}

void Test1()
{
    printf("Test1 begins:\n");

    char* text = "Hello world";

    CMyString str1(text);
    CMyString str2;
    str2 = str1;

    printf("The expected result is: %s.\n", text);
    printf("The actual result is:   ");
    str2.Print();
    printf(".\n");
}

int main()
{
    Test1();
    return 0;
}

文章来源：

http://blog.csdn.net/buyingfei8888/article/details/17300713

http://blog.csdn.net/buyingfei8888/article/details/17306055

http://blog.csdn.net/buyingfei8888/article/details/17307329