深浅拷贝实现

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

//浅拷贝
//对象拷贝时，只拷贝位于stack中的数据，不会拷贝heap中的数据
//使用默认的拷贝构造和默认的=赋值 属于浅拷贝
//浅拷贝的问题
//当类中存在指针成员变量时，进行浅拷贝后，目标对象与源对象的该指针成员变量将会指向同一块 heap 内存区域（而非每个对象单独占用一块内存区域），
//这就可能导致由于共用该段内存区域而产生内存覆盖、重复释放内存等问题

//深拷贝
//对象拷贝时，将对象位于 stack 域和 heap 域中的数据都进行拷贝
//对赋值运算符或拷贝构造函数进行重载

class Person {
public:
	Person(){}
	Person(string name,int age){
		m_name = new string(name);
		m_age = age;
	}

	//重载拷贝构造实现深拷贝
	Person(Person& p);

	//重载等号实现深拷贝
	Person& operator=(Person& p);

	string get_name() {return *(this->m_name);}

	int get_age() {return m_age;}

	void chg_age(int& age) {this->m_age = age;}

	void chg_name(string& s) {*(this->m_name) = s;}

	void showP();

	~Person() {
		cout << "析构函数调用" << endl;
		//用if是因为，new可能在堆区开辟空间不成功，不成功会返回Null
		if (m_name != NULL) {
			delete m_name;
			m_name = NULL;
		}
	}

private:
	string* m_name=NULL;
	int m_age=0;
};

//重载等号实现深拷贝
Person& Person::operator=(Person& p) {
	cout << "重载=" << endl;

	// 适应自赋值（obj = obj）操作
	if (this == &p) { return *this; }

	//释放原有空间 避免内存泄漏
	if (!this->m_name) {
		delete this->m_name;
		this->m_name = NULL;
	}

	//新建空间
	this->m_name = new string(*(p.m_name));
	//深拷贝
	//*(this->m_name) = *(p.m_name);

	//拷贝stack上的值
	this->m_age = p.m_age;

	return *this;
}


//重载拷贝构造实现深拷贝
Person::Person(Person& p) {

	cout << "重载拷贝构造" << endl;

	//方法一：
	//申请内存空间
	//this->m_name = new string;

	//用if是因为，new可能在堆区开辟空间不成功，不成功会返回Null
	/*if (m_name != NULL) {
		*(this->m_name) = *(p.m_name);
	}*/

	//方法二：
	this->m_name = new string(*(p.m_name));

	//以下写法错误
	//拷贝构造初始化时，先默认创建一个对象，此时对象中指针为空
	/*if(m_name!=NULL){
		this->m_name = new string(*(p.m_name));
	}*/
	
	this->m_age = p.m_age;
}

void Person::showP() {
	cout << "姓名：" << *(this->m_name) << " 年龄：" << this->m_age << endl;
}

void test01() {
	Person p1("孙悟空", 999);
	p1.showP();
	Person p2(p1);
	p2.showP();
	Person p3 = p1;//拷贝构造
	p3.showP();
}

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