【C++】浅拷贝深拷贝写时拷贝

文章目录

• 1. 经典的string类问题
• 2. 浅拷贝
• 3. 深拷贝
• • 3.1 传统写法的String类
  • 3.2 现代写法的String类
  • 4. 写时拷贝

    1. 经典的string类问题

    上一篇博客已经对string类进行了简单的介绍，大家只要能够正常使用即可。

    链接：【C++】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 string");
    	String s2(s1);
    }
    

    

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

    2. 浅拷贝

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

    就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。

    

    可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。

    

    3. 深拷贝

    如果一个类中涉及到资源的管理，其拷贝构造函数，赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

    

    3.1 传统写法的String类

    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);
    	}
    	
    	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;
    };
    

    3.2 现代写法的String类

    class String
    {
    public:
    	String(const char* str = "")
    	{
    		if (nullptr == str)
    		{
    			assert(false);
    			return;
    		}
    		_str = new char[strlen(str) + 1];
    		strcpy(_str, str);
    	}
    	
    	String(const String& s)
    		: _str(nullptr)
    	{
    		String strTmp(s._str);
    		swap(_str, strTmp._str);
    	}
    	
    	// 对比下和上面的赋值那个实现比较好？
    	String& operator=(String s)
    	{
    		swap(_str, s._str);
    		return *this;
    	}
    	
    	//String& operator=(const String& s)
    	//{
    	//	if (this != &s)
    	//	{
    	//		String strTmp(s);
    	//		swap(_str, strTmp._str);
    	//	}
    	//	return *this;
    	//}
    	~String()
    	{
    		if (_str)
    		{
    			delete[] _str;
    			_str = nullptr;
    		}
    	}
    	
    private:
    	char* _str;
    };
    

    传统写法就是老老实实自己开空间、自己拷贝数据、自己删除旧空间；而现代写法则利用了swap()函数以及局部变量出作用域自动销毁的特性，让函数和编译器帮我们“打工”，我们只要坐享其成即可。这两种方式在效率上并没有什么区别，只是让代码看起来更简洁，但这又会使代码的可读性降低。总体来说，我还是更偏向于传统写法。

    4. 写时拷贝

    

    写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

    引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数-1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象也在使用该资源。

    ---

    本文完