c++学习笔记-----实现一个简易string

面试中我们可能被要求编写一个简单string类函数，那我们要清楚实现一个简易string，对于公有成员我们需要构造函数、构造拷贝函数、析构函数、[ ]重载、以及赋值重载，私有成员我们只需要定义它的_str就好，这都是需要我们实现的。
在这之前我们先要理解深浅拷贝这一概念，浅拷贝简单理解就是值拷贝，它是相当于s2把s1的值拷贝过去，两个类同时共用一块空间，程序结束时s1调析构函数析构s1这一空间，s2在调用析构时这一空间已经被释放过了，系统则会报错。

string s1(s2);

而深拷贝则是在对s1进行拷贝构造时调用构造函数立即开辟一块跟s2相同大小的空间，在该空间存入拷贝好的s2的值，从而实现深拷贝（空间拷贝）。

一、string类中各个成员函数（传统写法）

（一）构造函数

//s1="hello"
string(char* str = "")
			:_str(new char[strlen(str) + 1])     //深拷贝开空间  +1是为‘\0’开的
		{
			strcpy(_str, str);       //将str的值拷贝到开辟好的和其一样大小的新空间_str中
		}

其中要说明函数内char* str为什么要给一个"",意思是相当于给str一个’\0’初始值，这样如果要定义string s1; 这个语句时，当要cout<<c_str时，cout会将_str当成char*进行处理，会找’\0’这一字符，找到后便会输出，如果不给默认缺省参数’\0’的话，会导致cout找不到’\0’而崩溃。
（二）拷贝构造函数

//s2(s1)
string(const string& s)   //传引用防止出现深拷贝
			:_str(new char[strlen(s._str)+1])   //深拷贝开空间  +1是为‘\0’开的
		{
			strcpy(_str, s._str);//将str的值拷贝到开辟好的和其一样大小的新空间_str中
		}

（三）[ ]重载函数

//s1[i]
char& operator[](size_t i)
	{
		return _str[i];
	}

（四）赋值重载函数

//s2=s1
		string& operator=(const string& s)
		{
			if (this != &s)   //防止出现自身赋值     s1=s1
			{
				delete[] _str;
				_str = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
			}
			return *this;
		}

（五）返回字符串函数

		const char* c_str()
		{
			return _str;
		}

（六）析构函数

		~string()
		{
			delete[] _str;
		}

二、完整代码

//简单实现string
namespace hehe
{
	class string
	{
	public:
//构造函数
		string(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);
		}
//[]重载函数
		char& operator[](size_t i)
		{
			return _str[i];
		}
//=重载函数
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				delete[] _str;
				_str = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
			}
			return *this;
		}
//返回字符串函数
		const char* c_str()
		{
			return _str;
		}
//析构函数
		~string()
		{
			delete[] _str;
		}
	private:
		char* _str;
	};
}

三、现代写法代码

namespace hehe
{
	class string
	{
	public:
//构造函数
		string(char* str = "")
			:_str(new char[strlen(str) + 1])
		{
			strcpy(_str, str);
		}
//拷贝构造函数
		string(const string& s)
			:_str(nullptr)      //先给_str一个空指针，方便下面和temp交换，交换完后temp内_str就为空指针，而不是一个随机值
		{
			string temp(s._str);//定义一个temp，此时temp会调用构造函数重新开一个和s.str一样大小的空间
				swap(temp);  //这里隐含了一个this 指针，相当于swap（this->_str,temp），然后直接将temp构造好的空间与s交换
		}
//[]重载函数
		char& operator[](size_t i)
		{
			return _str[i];
		}
//=重载函数
		string& operator=(const string s)   //这里会发生一次深拷贝
		{
			swap(s);//相当于swap（this->_str,s）
			return *this;
		}
//返回字符串函数
		const char* c_str()
		{
			return _str;
		}
//析构函数
		~string()
		{
			delete[] _str;
		}
	private:
		char* _str;
	};
}