C++string类的实现

C++中提供了一种新的数据类型——字符串类型(string)。实际上string并不是C++的基本类型，它是在C++标准库中声明的一个字符串类，用这种数据类型可以定义对象，每一个字符串变量都是string类的一个对象。标准库类型string表示可变长的字符序列，使用string类型必须首先包含它的头文件。
作为标准库的一部分，string定义在命名空间std中。
【例】

#include<string>//注意这里没有.h 
using namespace std;

string类的意义有两个：第一个是为了处理char类型的数组，并封装了标准C中的一些字符串处理的函数。而当string类进入了C++标准后，它的第二个意义就是一个容器。

string类有106个成员接口函数。C++ 的一个常见面试题是让你实现一个 String 类，限于时间，不可能要求具备 std::string 的功能，但至少要求能正确管理资源。具体来说：
1）能像 int 类型那样定义变量，并且支持赋值、复制。
2）能用作函数的参数类型及返回类型。
3）能用作标准库容器的元素类型，即 vector/list/deque 的 value_type。（用作 std::map 的 key_type 是更进一步的要求，本文从略）。

下面是模拟实现string类的几个重要函数：
1、构造函数
【例】

#define _CRT_SECURE_NO_WARNINGS
#include<string>

using namespace std;

class String
{
public:
	String(char *str = "")
	{
		if (str == NULL)
		{
			_str = new char[1];//为了与delete[]配合使用
			*_str = '\0';
			size = 0;
		}
		else
		{
			int length = strlen(str);
			_str = new char[length + 1];
			strcpy(_str, str);
			size = length;
		}
	}
	~String()
	{
		if (NULL != _str)
		{
			delete[] _str;//delete[]释放的空间必须是动态分配的
		}
	}
private:
	char *_str;//指向字符串的指针
	size_t size;//保存当前字符串长度
};

void Test2()
{
	String s1("hello");
	String s2(new char[3]);
}

int main()
{
	Test2();
	system("pause");
	return 0;
}

释：在构造函数中，_str被初始化为空字符串（只有‘\0’）而不是NULL。因为C++中的任何字符串的长度至少为1（即至少包含一个结束符‘\0’）。空字符串也是有效的字符串，它的长度为1，因此他代表一块合法的内存单元而不是NULL。

2、拷贝构造函数
1）浅拷贝
【例】

String::String(const String& s)//浅拷贝
	:_str(s._str)
{}

void Test2()
{
	String s1("hello");
	String s2(s1);
}

以上代码会使系统崩溃。因为s1只是将_str的地址传给s2中的_str，即浅拷贝（位拷贝）,如下图所示：

由图可知：s1和s2指向同一块内存，析构时先对s2释放“hello”这块空间，当要再析构s1时，系统将崩溃。

释：浅拷贝又称为位拷贝，编译器只是将指针的内容拷贝过来，导致多个对象共用一块内存空间，当其中任意对象将这块空间释放之后，当再次访问时将出错。

解决方法：（深拷贝）给要拷贝构造的对象重新分配空间。
【例】

String::String(const String& s)//深拷贝
	:_str(new char[strlen(s._str) + 1])
{
	strcpy(_str, s._str);
	size = strlen(s._str);
}

void Test2()
{
	String s1("hello");
	String s2(s1);
}

其运行的状态如图所示：

由图可知：拷贝的对象s2中_str的值（字符串的地址）和s1对象中的_str的值不同，“hello”保存在地址不同的两个空间里，说明了系统为对象重新开辟了空间——深拷贝。

其工作原理如图所示：

3、拷贝赋值函数
【例】

	//方法一：
	String& String::operator=(const String& s)
	{
		if (this != &s)//检查自赋值
		{
			delete[]_str;
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
	      size = strlen(s._str);

		}
		return *this;//为了支持链式访问
	}

	//方法二：
	String& String:: operator=(const String& s)
	{
		if (this != &s)//1)检查自赋值
		{//2)创建临时变量获得分配的内存空间，并复制原来的内容
			char *tmp = new char[strlen(s._str) + 1];
			strcpy(tmp, s._str);
			delete[]_str;//3）释放原有的内存
			_str = tmp;
			size = strlen(s._str);
		}
		return *this;//4）返回本对象引用
	}

其运行状态如图所示：

分析：一般情况下，上面的两种写法都可以，但是相对而言，第二种更优一点。
方法一，先释放原有的空间，但是如果下面用new开辟新空间时失败了，而这时将s2赋值给s3,不仅不能成功赋值（空间开辟失败），还破坏了原有的s3对象。
方法二，先开辟新空间，将新空间的地址赋给一个临时变量，就算这时空间开辟失败，也不会影响原本s3对象。
综上所述：第二种方法更优一点。

注意：最后的返回值是为了支持链式访问。
例如：s3 = s2 = s1;

4、拷贝构造函数的现代写法：
【例】

String::String(const String& s)
	:_str(NULL)//一定要对_str初始化
{
	String tmp(s._str);
	std::swap(tmp._str, _str);
}

释：如果没有初始化，_str的值很可能是一个随机值，其指向的内存空间是不合法的。当tmp._str和_str交换后析构tmp就会出错。

5、赋值运算符重载函数的两种现代写法
【例】

//第一种：
String& String::operator=(String s)
{
	std::swap(_str, s._str);
	return *this;
}

//第二种：
String& String::operator=(const String& s)
{
	if (this->_str != s._str)
	{
		String tmp(s);
		std::swap(tmp._str, _str);
	}
	return *this;
}

在面试时，一般写出上面四个string类的成员函数即可，除非面试官特别要求。