String浅拷贝与深拷贝问题

String浅拷贝与深拷贝问题

---

---

一、使用深拷贝的原因

我们都知道 如果我们在类内没有显示定义string的拷贝构造函数，编译器会自动给我们生成一个拷贝构造函数，而这个拷贝构造函数执行的操作仅仅是浅拷贝

什么是浅拷贝呢？ 这是string内部的私有成员

	private:
		char* _str;
		size_t _size;
		size_t _capacity;

	string s2(s1)

在这里我们用s1拷贝构造s2，如果我们没有显示定义构造函数，而是只用默认生成的拷贝构造函数，编译器会仅仅将s1内部_str指针指向的地址拷贝给s2内部的_str指针
导致s1与s2指向同一个字符串
这就会导致一个严重的问题，当s1与s2需要销毁的时候会分别调用他们的析构函数，而s1与s2指向的是同一块空间，此时这块空间就会析构两次导致程序崩溃
同时如果s1与s2指向的是同一块空间，达不到我们想要的效果，我们需要的是两个string，而实际上我们在操作一个string，改变任意一个另一个都会改变

所以在实现string的拷贝构造函数时候，我们要显示定义，并且完成深拷贝，否则会出现大问题

二、实现string类的接口，并完成测试，利用深拷贝和深赋值实现

#include <iostream>

//实现string类的接口，并完成测试，要求利用深拷贝和深赋值实现

using namespace std;

namespace Tlzns
{

	class string

	{

	public:

		string(const char* str = "")
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		string(const string& s)
			:_size(s._size)
			,_capacity(s._capacity)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

		string& operator=(const string& s)
		{
			_capacity = s._capacity;
			_size = s._size;

			char* tmp = new char[_capacity + 1];
			strcpy(tmp, s._str);

			delete[] _str;
			_str = tmp;

			return *this;
		}


		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}


	//private:

		char* _str;
		size_t _size;
		size_t _capacity;
	};


	void string_test1()
	{
		char a[] = "hello world";
		string s1(a);
		cout << s1._str << endl;

		string s2(s1);
		cout << s2._str << endl;

		string s3;
		s3 = s2;
		cout << s3._str << endl;

	}
}


int main()
{
	Tlzns::string_test1();
	return 0;
}

---