【面试题一】：string类的深浅拷贝

#pragma once
#include <iostream>
using namespace std;

//浅拷贝(析构对象时会出错)
class CMyString
{
public:
	//构造函数
	CMyString(char* pData = "")
		:m_pData(new char[strlen(pData)+1])
	{
		if (*pData)
		{
			strcpy(m_pData,pData);
		}
		else
		{
			*m_pData = '\0';
		}
	}

	//拷贝构造函数
	CMyString(const CMyString& str)
		:m_pData(NULL)
	{
		//浅拷贝
		m_pData = str.m_pData;
	}

	//析构函数
	~CMyString()
	{
		if (m_pData)
		{
			delete []m_pData;
			m_pData = NULL;
		}
	}

	//赋值运算符重载
	CMyString& operator=(const CMyString& str)
	{
		//判断是不是自己给自己赋值
		if (this != &str)
		{
			//浅拷贝
			m_pData = str.m_pData;
		}
		return *this;
	}

private:
	char* m_pData;
};

void TestString()
{
	CMyString s1("abcd");
	CMyString s2(s1);
	CMyString s3;
	s3 = s1;
}


//深拷贝
class String
{
public:
	//构造函数
	String(const char* pData = "")
		:_str(new char[strlen(pData)+1])
	{
		if (*pData)
		{
			strcpy(_str,pData);
		}
		else
		{
			*_str = '\0';
		}
	}

	//拷贝构造函数
	String(const String& s)
		:_str(new char[strlen(s._str)+1])
	{
		传统写法
		//_str = NULL;//防止交换后tmp指向随机空间，函数调用完成导致崩溃
		//String tmp(s._str);//给出临时变量进行交换，防止s的值被改变
		//swap(_str,tmp._str);

		//简洁写法
		strcpy(_str,s._str);
	}

	赋值运算符重载（返回类对象的引用，方便连续赋值）
	//String& operator=(const String& s)
	//{
	//	if (this != &s)//预防自己给自己赋值
	//	{
	//		传统写法1
	//		//char* tmp(new char[strlen(s._str)+1]);//开辟新空间
	//		//strcpy(tmp,s._str);//为新空间赋值
	//		//delete []_str;//释放旧空间 
	//		//_str = tmp;

	//		传统写法2
	//		//delete []_str;
	//		//_str = new char[strlen(s._str)+1];//在分配内存之前释放原有空间，有可能违背异常安全原则
	//		//strcpy(_str,s._str);

	//		简洁写法1
	//		//String temp(s);//调用拷贝构造
	//		//swap(_str,temp._str);
	//		
	//		//简洁写法2
	//		String temp(s._str);//调用构造函数
	//		swap(_str,temp._str);
	//	}

	//	return *this;
	//}
	//简介写法3
	String& operator=(String s)
	{
		swap(_str,s._str);
		return *this;
	}

	//析构函数
	~String()
	{
		if (_str)
		{
			delete []_str;
			_str = NULL;
		}
	}
	
private:
	char* _str;
};

void TestDepthString()
{
	String s1("abcd");
	String s2(s1);
	String s3;
	s3 = s1;
}