深浅拷贝以及解决浅拷贝（以string浅拷贝为例）

一、什么是浅拷贝

        在类和对象的时候，其中编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

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

下面代码+图解释一下：

#include <iostream>

using namespace std;

namespace HK
{
	class string
	{
	public:
		string(const char* str = "")
		{
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}


		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}


	private:
		char* _str;
	};



}

int main()
{

	HK::string s1("hello");

	HK::string s2(s1);

	return 0;
}

上面代码中，在我自己的命名空间里面，string 类里面显示写了构造和析构，拷贝构造和赋值都没写，默认生成的对内置类型完成值拷贝，这里的 char* 就是内置类型。（int char short 等等常见的类型以及指针都是内置类型）

那么浅拷贝是什么样，如下图：

注意看，s2 拷贝 s1 地址都是一样的，析构的时候，s2 析构之后有没有发现 s1 的也被析构了？

因为 s2 和 s1 指向同一地址，如下图：

 

所以析构的时候，也会影响另一个。

那么怎么解决？

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

二、什么是深拷贝

        深拷贝∶给每个对象独立分配资源，保证多个对象之间不会因共享资源而造成多次释放造成程序奔溃问题。

下面代码+图解释：

#include <iostream>

using namespace std;

namespace HK
{
	class string
	{
	public:
		string(const char* str = "")
		{
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}

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

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* pStr = new char[strlen(s._str) + 1];
				strcpy(pStr, s._str);
				delete[] _str;
				_str = pStr;
			}
			return *this;
		}

		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}


	private:
		char* _str;
	};
}

int main()
{

	HK::string s1("hello");

	HK::string s2(s1);

	HK::string s3("world");
	
	HK::string s4 = s3;

	return 0;
}

上面代码中，我显示写了拷贝和赋值，实现了深拷贝， 那么现在怎么样？如下：

 注意看上面的调试窗口， s2 拷贝之后的地址和 s1 是不一样的，s3 赋值给 s4，s4 和 s3 地址也是不一样的，下面截图出来，如下：

以上就是深浅拷贝。