深拷贝与写实拷贝----string

摘要

学过或者了解过C++都知道，，，在C++中面向对象实现一个类 、、、的时候必须要考虑的就是

【深浅拷贝】的问题 ？？

所以我写了这篇文章来简要的讲述一下C++中深浅拷贝的问题以及由此引发的    另一个  概念【写实拷贝】

概念的解析

所谓的深浅拷贝就是 

C++中；；；；；定义一个类的时候；；；

其拷贝构造函数、、、还有赋值运算符的重载   的不同的实现方法；；；

当一个类的成员变量中带有的是  指针；；；

当使用这个类对象拷贝生成一个对象的的时候、、、如果直接赋值的话，，，，，类析构的时候就会出现问题；；；

所以在这种时候 我们就需要来考虑深拷贝的问题；；；；

关于深拷贝的问题、、、大致主要有两种的方法：

方法1、

直接重新申请一段相同大小的空间、、、并赋值成相同的值  ；；；

这就是直接的深拷贝；

方法2、

在类的成员变量中加上一个   【引用计数 】用来表示当前有多少个对象在公用一段空间 

类析构时、(要是引用计数为1  直接释放这段空间 )(否则的话就将这个对象的成员变量的指针置为NULL)

这种方法  就是  带有引用计数的浅拷贝的  实现深拷贝

【灰常的重要】

但是上述的方法2     虽然实现了   深拷贝 、、、但是还遗留了一个很大的问题；；；

假设有 4  个string类的对象     a    b   c     d；公用的是 同一段的空间 

现在要对  对象a   的内容进行修改、、、、

但是要是修改了  a的 内容   b  c  d的内容也会被修改(因为它们用的是同一段空间)

所以也就出现了  【写实拷贝】这个   概念》》》》

当遇到上述这种情况下、、、、谁  改变 就对谁进行拷贝   ------这就是 写实拷贝

上述的两种方法

Windows系统下的编程环境使用的是  方法1

Linux系统下是用的是 方法2

通常情况下、、、、、我们都是使用的是  string来演示实现     深拷贝、、、与写实拷贝的

代码的实现

下面我来实现这段代码的实现

#pragma  once 
#include <assert.h>
//说道string类的两个主要考点就是 
//深拷贝
//浅拷贝   写实拷贝 ()


//深拷贝
class String 
{
public:
	String(const  char  * str = "")
	{
		//要是传进来的字符串为 NULL
		if(str == NULL)
		{
			//我们需要创建一个内容为 /0的字符串
			_str  =new char [1];
			*_str  = '/0';
		}
		else
		{
			//否则，，，开辟一个长度为 str长度+1； 
			_str  = new char [strlen(str)+1];
			strcpy(_str,str);  
		}
	}

	//深拷贝的拷贝构造函数 
	//String(const  String &  str)
	//	:_str(new char[strlen(str._str)+1])
	//{
	//	//先为字符串开辟一个空间
	//	//将内部的数据拷贝
	//	strcpy(_str,str._str);
	//}

	//简介版 的拷贝构造函数 

	String (const String &  str)
		:_str(NULL)//现将当前的对象的字符串的指针赋为空 ，，，必须要写 
	{
		//使用的是 str内部的字符串的指针，，来构造一个新的对象 str1；
		String  str1(str._str);
		//将当前的对象的_str  与  重新生成的新对象的_str 交换
		swap(_str,str1._str);
	}
	
	//深拷贝的赋值运算符的重载
	//String & operator = (const  String  &  str)
	//{
	//	if(this!= &str)
	//	{
	//		//开辟一个空间 
	//		char *  tmp  =new char[strlen(str._str)+1];
	//		//将原来的空间释放
	//		delete[]_str;
	//		//将内容拷贝到所开辟的位置 
	//		strcpy(tmp,str._str);
	//		//将开辟的空间给当前的类
	//		_str = tmp;
	//	}
	//	return *this;
	//}

	//简介版 的赋值运算符的重载
	String &    operator =(const  String  &  str)
	{
		//防止自己给自己赋值
		if(this  != &  str)
		{
			String str1(str);//使用拷贝构造函数  ，，，来生成一个新的对象 
			//先将当前对象的_str释放 ，，，，并且赋值成 NULL
			delete[]  _str;
			_str = NULL;
			swap(_str,str1._str);
		}
		return  *this;
	}
	~String()
	{
		if(_str != NULL)
		{
			delete []  _str;
		}
		_str   =NULL;
	}


	//重载【】
	char & operator[](size_t n)
	{
		assert(n < strlen(_str) );
		return  *(_str+n);
	}
protected:
	char  *_str;
};



//引用计数的浅拷贝     写实拷贝
class StringS
{
public:
	StringS(const  char  * str = "")
	{
		//要是传进来的字符串为 NULL
		if(str == NULL)
		{
			//我们需要创建一个内容为 /0的字符串
			_str  =new char [1];
			*_str  = '/0';
		}
		else
		{
			//否则，，，开辟一个长度为 str长度+1； 
			_str  = new char [strlen(str)+1];
			strcpy(_str,str);  
		}
		_count = new int(1);
	}

	//拷贝构造函数 
	StringS(const  StringS &  str)
		:_str (str._str)
		,_count(str._count)
	{
		(*_count)++;
	}
	//带有引用计数的赋值运算符的重载 
	StringS &  operator=( const StringS  &  str)
	{
		if(_str !=  str._str)
		{
			if(*_count == 1)
			{
				delete[] _str;
				_str  =  str._str;
			}
			else
			{
				(*_count)--;
				_str  = str._str;
			}
			_count  = str._count;
			(*_count) ++;
		}
		return  *this;
	}
	~StringS()
	{
		if(*_count == 1)
		{
			delete[] _str;
			delete _count;
		}
		else
		{
			(*_count) --;
		}
		_str = NULL;
		_count =NULL;
	}


	//写实拷贝 
	//当某个对象要进行 写的话   ，，，就要对其 单独进行拷贝 
	char & operator[](size_t  n)
	{
		assert(n < strlen(_str) );
		if(*_count != 1)//如果这个数 多个 对象使用的话 
		{
			char  *  tmp  = new  char[strlen(_str)+1];
			strcpy(tmp,_str);
			_str  =  tmp;
			(*_count)--;
			_count  = new int(1);
		}
		return *(_str+n);
	}
protected:
	char *  _str;
	int  *  _count ;//表示的是 引用计数

};
void testString()
{
	String  st(NULL);
	String  st1;
	String  st2("we are happy");
	String  st3(st2);
	st1 = st3;
}
void testStringS()
{
	StringS  st(NULL);
	StringS  st1;
	StringS  st2("we are happy");
	StringS  st3(st2);
	st1 = st3;
	st2[2];
}