C++String(模拟实现，相关函数，深拷贝，浅拷贝，写时拷贝(引用计数) )

string

string类对象的常见构造

void Teststring()
{
	string s1; // 构造空的string类对象s1
	string s2("hello bit"); // 用C格式字符串构造string类对象s2
	string s3(s2); // 拷贝构造s3
}

容量操作

size 返回字符串有效字符长度
length 返回字符串有效字符长度
capacity 返回空间总大小
empty 检测字符串释放为空串，是返回true，否则返回false
clear 清空有效字符
clear()只是将string中有效字符清空，不改变底层空间大小。
reserve 为字符串预留空间**
resize 将有效字符的个数该成n个，多出的空间用字符c填充
resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。

reserve和resize的区别
reserve不会改变string中有效元素的个数，不能改变string的size大小,且通过reserve申请的空间只可以调大，不可以调小，即使函数调用不出错。
resize可以改变string中有效元素的个数，可以改变string的size()，并且还可以对string填充数据，当元素增多时大于了本身底层容量，可能会进行扩容，但是如果减小元素，底层空间总大小不变。

void Teststring1()
{
	// 注意：string类对象支持直接用cin和cout进行输入和输出
	string s("test string!!!"); cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	// “aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	// 注意此时s中有效字符个数已经增加到15个
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	// 将s中有效字符个数缩小到5个
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
}

访问及遍历操作

operator[] 返回pos位置的字符，const string类对象调用
begin+ end
begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭
代器
rbegin + rend 和 begin+end 刚好相反。
范围for C++11支持更简洁的范围for的新遍历方式

//三种遍历方式
void Teststring()
{
	string s("hello Bit");
	// 1. operator[] + 普通for
	for(size_t i = 0; i < s.size(); ++i)
		cout<<s[i]<<endl;
	// 2.迭代器
	string::iterator it = s.begin();
	while(it != s.end())
	{
		cout<<*it<<endl;
		++it;
	}
	string::reverse_iterator rit = s.rbegin();
	while(rit != s.rend())
		cout<<*rit<<endl;
	
	// 3.范围for
	for(auto ch : s)
		cout<<ch<<endl;
}

** 修改操作**

push_back 在字符串后尾插字符c
append 在字符串后追加一个字符串
operator+= 在字符串后追加字符串str
c_str 返回C格式字符串
find + npos 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
string substr (size_t pos = 0, size_t len = npos) const;
substr 在str中从pos位置开始，截取n个字符，然后将其返回。
字符串三种追加(拼接)方式
1.push_back
2.append
3.operator+=

string类的模拟实现

#include<iostream>
#include<string.h>
using namespace std;
namespace mystring
{
	class string
	{
		friend ostream& operator<<(ostream& out, const string &str);
	public:
		//构造函数
		string(const char* str = "")
		{
			// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
			if (nullptr == str)
			{
				m_str = new char[1]{'\0'};
				//_str[0] = '\0'
			}
			else
			{
				m_str = new char[strlen(str) + 1];
				strcpy(m_str, str);
			}
		}
		//拷贝构造
		string(const string& str):m_str(nullptr)
		{
			//法1
			m_str = new char[strlen(str.m_str) + 1];
			strcpy(m_str, str.m_str);
			//法2
			string strTmp(str.m_str);
			swap(m_str, strTmp.m_str);
		}
		//赋值语句
		string& operator=(string& str)
		{
			//法1
			if (this != &str)
			{
				delete m_str;
				m_str = new char[strlen(str.m_str) + 1];
				strcpy(m_str, str.m_str);
			}
			return *this;
			//法2
			swap(m_str, str.m_str);
			return *this;
		}
		//析构函数
		~string()
		{
			if (m_str)
			{
				delete m_str;
				m_str = nullptr;
			}
		}
	private:
		char* m_str;
	};
	ostream& operator<<(ostream& out, const string &str)
	{
		out << str.m_str;
		return out;
	}
}

void main()
{
	mystring::string s1("123");
	mystring::string s2(s1);
	mystring::string s3;
	s3 = s1;
	cout << s3 << endl;
}

深拷贝，浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。
如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以 当继续对资源进项操作时，就会发生发生了访问违规。
也就说系统在释放资源的时候会将同一份资源被释放多次，造成错误，尤其对于包含指针类型进行操作的时候
深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。
即不仅要拷贝其值，也要分配和其一样大小的空间。这样每个对象都有自己空间，在释放时候就不会干扰

写时拷贝

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

//引用计数版string类模拟实现
namespace mystring
{
	class string
	{
		friend ostream& operator<<(ostream& out, const string &s);
	public:
		string(const char* str = "") :m_use_count(new int(1))
		{
			if (nullptr == str)
			{
				m_str = new char[1]{'\0'};
			}
			else
			{
				m_str = new char[strlen(str) + 1];
				strcpy(m_str, str);
			}
		}
		string(const string &s) :m_str(s.m_str), m_use_count(s.m_use_count)
		{
			//增加引用计数
			//(*m_use_count)++;
			increase_ref_count();
		}
		string& operator=(const string &s)
		{
			if (this != &s)
			{
				decrease_ref_count();  //针对当前对象指向的原空间引用计数-1
				m_str = s.m_str;
				m_use_count = s.m_use_count;
				increase_ref_count(); //针对当前对象指向的新空间引用计数+1
			}
			return *this;
		}
		~string()
		{
			decrease_ref_count();
		}
	public:
		void increase_ref_count()
		{
			(*m_use_count)++;
		}
		void decrease_ref_count()
		{
			if (--(*m_use_count) == 0)
			{
				//释放数据空间
				delete[] m_str;
				m_str = nullptr;
				//释放引用计数空间
				delete m_use_count;
				m_use_count = nullptr;
			}
		}
	private:
		char* m_str;
		//引用计数  假如3个对象共同指向同一个地址，那么引用计数为3， 当引用计数为0时，此时空间才被释放
		int *m_use_count;
	};

	ostream& operator<<(ostream& out, const string &s)
	{
		out << s.m_str;
		return out;
	}
};