C++:string类（3）string深拷贝和深赋值

1.经典的string类问题

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让 学生自己来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析 构函数。大家看下以下string类的实现是否有问题？

class String

{

public:
 /*String()

 :_str(new char[1])

 {*_str = '\0';}

 */

 //String(const char* str = "\0") 错误示范

 //String(const char* str = nullptr) 错误示范

 String(const char* str = "")
 {
 // 构造String类对象时，如果传递nullptr指针，可以认为程序非

 if (nullptr == str)
 {
 assert(false);
 return;
 }
 _str = new char[strlen(str) + 1];
 strcpy(_str, str);
 }
 ~String()
 {
 if (_str)
 {
 delete[] _str;
 _str = nullptr;
 }
 }

private:
 char* _str;
};

// 测试

void TestString()
{
 String s1("hello bit!!!");
 String s2(s1);
}

说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认 的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内 存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

1.2 浅拷贝 

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致 多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该 资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。

1.3 深拷贝 

 同时引入深赋值

/*方法一: string的传统版实现*/

namespace bit

{

	class string

	{

	public:

		//构造函数

		string(const char* str = "")

		{

			// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下

			if (nullptr == str)

			{

				assert(false);

				return;

			}



			_str = new char[strlen(str) + 1];

			strcpy(_str, str);

		}



		//拷贝构造函数

		string(const string& s)

			: _str(new char[strlen(s._str) + 1])

		{

			strcpy(_str, s._str);

		}



		//赋值语句 初级阶段的实现，如果考虑异常安全，可以参考剑指offer一书的面试题1

		string& operator=(const string& s)

		{

			if (this != &s)

			{

				delete[]_str;

				_str = new char[strlen(s._str) + 1];

				strcpy(_str, s._str);

			}



			return *this;

		}



		//析构函数

		~string()

		{

			delete[]_str;

			_str = nullptr;

		}



	private:

		char* _str;

	};

}



/*方法二: String的临时对象交换现代版*/

namespace bit

{

	class string

	{

	public:

		//构造函数 考虑str为空的情形

		string(const char* str = "")

		{

			// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下

			if (nullptr == str)

			{

				assert(0);

				return;

			}



			_str = new char[strlen(str) + 1];

			strcpy(_str, str);

		}



		//拷贝构造函数 通过临时对象的交换方式进行拷贝构造，构造对象借助之前实现的普通构造函数来构造   //对象,然后通过交换对象的内部指针的指向，从而达到拷贝构造对象，好处就是如果出错，其根本就是   //构造函数的错误，我们相当于把错误最终归结为构造函数

		string(const string& s)

			: _str(nullptr)

		{

			string strTmp(s._str);

			swap(_str, strTmp._str);

		}



		//赋值语句 通过临时对象的交换方式进行实现，

		//如果考虑异常安全，可以参考剑指offer一书的面试题1

		//这种交换方式在赋值语句中，有利于预防内存泄漏，因为交换完成的临时对象，一旦生存作用域结    

		//束，就会自动调用其析构函数，释放对应的资源

		string& operator=(const string& s)

		{

			if (this != &s)

			{

				string strTmp(s);

				swap(_str, strTmp._str);

			}



			return *this;

		}



		//析构函数,当_str不为空时才进行释放工作并且以数组方式进行释放

		~string()

		{



			delete[] _str;

			_str = nullptr;

		}



	private:

		char* _str;

	};

}