C++浅拷贝和深拷贝

#include <iostream>
using namespace std;

class CExample
{
public:
	CExample(int a = 0, int b = 0)
	{
		this->m_a = a;
		this->m_b = b;
		this->m_char = new char[10];
	}
	CExample(CExample& other)
	{
		this->m_a = other.m_a;
		this->m_b = other.m_b;
		this->m_char = new char[10];//新的内存申请
	}
	~CExample()
	{
		if(this->m_char != 0)
		{
			delete[] m_char;
		}
	}

	int m_a;
	int m_b;
	char* m_char;
};

int main()
{
	CExample c(10, 10);
	CExample d = c;

	cout<<c.m_a<<" "<<c.m_b<<" "<<(void*)c.m_char<<endl;
	cout<<d.m_a<<" "<<d.m_b<<" "<<(void*)d.m_char<<endl;

	return 0;
}

例二：

由http://www.weixueyuan.net/view/6344.html稍微作了修改而来。析构函数就不实现了

#include<iostream>
using namespace std;
class Array
{
public:
    Array(){length = 0; num = NULL;};
	Array(const Array & other);
    Array(int * A, int n);
    void setnum(int value, int index);
    int * getaddress();
        int getlength(){return length;}
    void display();
private:
    int length;
    int * num;
};
Array::Array(int *A, int n)
{
    num = new int[n];
    length = n;
    for(int i=0; i<n; i++)
        num[i] = A[i];
}
Array::Array(const Array & other)//如果不显式的实现拷贝构造函数，编译器默认的浅拷贝，将与实际我们想要的结果不一样。
{
	if(other.length != 0)
	{
		this->num = new int[other.length];
		memcpy(this->num, other.num, other.length*sizeof(int));
		this->length = other.length;
	}
}
void Array::setnum(int value, int index)
{
    if(index < length)
        num[index] = value;
    else
        cout<<"index out of range!"<<endl;
}
void Array::display()
{
    for(int i=0; i<length; i++)
        cout<<num[i]<<" ";
    cout<<endl;
}
int * Array::getaddress()
{
    return num;
}
int main()
{
    int A[5] = {1,2,3,4,5};
    Array arr1(A, 5);
    arr1.display();
    Array arr2(arr1);
    arr2.display();
    arr2.setnum(8,2);
    arr2.display();
    arr1.display();
    cout<<arr1.getaddress()<<" "<<arr2.getaddress()<<endl;
    return 0;
}

总结：

1、浅拷贝，即拷贝构造函数，将已声明的对象的成员变量简单赋值给一个新的类的对象。

2、深拷贝，即拷贝构造函数，类的对象的成员变量存在新的内存申请，而不是简单的对象成员变量的简单赋值。

3、构造类时候，显式的实现拷贝构造函数是好习惯，以免出现一些不可预测的问题。

4、如果不显式的实现拷贝构造函数，编译器会自动生成拷贝构造函数，这里的拷贝构造函数就是浅拷贝。