一、为什么学习string类？

• C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
• 在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。

二、标准库中的string类

  1. 定义

string类的文档介绍（注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转）

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(关于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string;
4. 不能操作多字节或者变长字符的序列。

注：在使用string类时，必须包含#include头文件以及using namespace std;

  2. 常用接口说明

     2.1 构造

// 1.测试string构造相关的接口
void text_string1()
{
	//常用
	string s1; //构造空string类对象
	string s2("Hello World!"); //用c字符串构造
	string s3(s2); //拷贝构造

	//不常用 了解即可
	string s4(s2, 2, 5); //从s2 下标2的位置开始，选择其及往后5个位置 拷贝构造s4
	string s5(s2, 2); //同上，第三个参数使用缺省值npos（结合相关文档），从下标2位置开始，有多少拷贝多少
	string s6(s2, 2, 30); //同上，第三个参数传参值大于 指定对象总长度时，也是有多少拷贝多少
	string s7("Hello World!", 5); //给定c字符串，从头顺序拷贝 指定个数的字符
	string s8(10, 'x'); //用指定个数 的指定字符 填充构造

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;
	cout << s6 << endl;
	cout << s7 << endl;
	cout << s8 << endl;
}

     2.2 容量操作

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：

• resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。
• 注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

// 2.测试string容量相关的接口  size/clear/resize
void text_string2()
{
	//1. 注意：string类对象支持直接用cin和cout进行输入和输出
	cout << "下方为1：" << endl;
	string s("hello, bit!!!");
	cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//2. 将s中的字符串清空，注意清空时只是将size清零，不改变底层空间的大小
	cout << "下方为2：" << endl;
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;

	//3. 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	// “aaaaaaaaaa”
	cout << "下方为3：" << endl;
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//4. 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	cout << "下方为4：" << endl;
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//5. 将s中有效字符个数缩小到5个 -> 删除
	cout << "下方为5：" << endl;
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//6. 测试reserve是否会改变string中有效元素个数 -> 不会,单纯扩容
	cout << "下方为6：" << endl;
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;

	//7. 测试reserve参数小于string的底层空间大小时，是否会将空间缩小 -> 不会，无变化
	cout << "下方为7：" << endl;
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;
}

// 利用reserve提高插入数据的效率，避免增容带来的开销
//====================================================================================
void text_PushBack() //多次扩容，开销大
{
	string s;
	size_t cap = s.capacity();
	cout << "无reserve的扩容情况:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (cap != s.capacity())
		{
			cap = s.capacity();
			cout << "capacity changed: " << cap << endl;
		}
	}
}

void text_PushBackReserve() //减少扩容次数，节省开销
{
	string s;
	s.reserve(100);
	size_t cap = s.capacity();
	cout << "有reserve的扩容情况:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (cap != s.capacity())
		{
			cap = s.capacity();
			cout << "capacity changed: " << cap << '\n';
		}
	}
}

     2.3 访问及遍历操作

// string的访问  s[]
void text_string3()
{
	string s1("hello Bit");
	const string s2("Hello Bit");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;

	// s2[0] = 'h';   代码编译失败，因为const类型对象不能修改
}

//string的遍历 -> begin()+end()   for+[]  范围for
// 注意：string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
void text_string4()
{
	string s("hello Bit");
	// 3种遍历方式：
	// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
	// 另外以下三种方式对于string而言，第一种使用最多
	// 1. for+operator[]
	for (size_t i = 0; i < s.size(); ++i)
		cout << s[i] << " ";
		//cout << s1.operator[](i) << endl;
		cout << endl;
		
	// 2.迭代器
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	// string::reverse_iterator rit = s.rbegin();
	// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	
	// 3.范围for
	for (auto ch : s)
		cout << ch << endl;
}

     2.4 修改操作

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好,避免多次扩容造成消耗

// 测试string：
// 1. 插入(拼接)方式：push_back  append  operator+= 
// 2. 正向和反向查找：find() + rfind()
// 3. 截取子串：substr()
// 4. 删除：erase
void text_string5()
{
	//1. 插入与追加
	cout << "下方为1：" << endl;
	string str;
	str.push_back(' ');   // 在str后插入空格
	str.append("hello");  // 在str后追加一个字符"hello"
	str += 'b';           // 在str后追加一个字符'b'   
	str += "it";          // 在str后追加一个字符串"it"
	cout << str << endl;
	cout << str.c_str() << endl;   // 以C语言的方式打印字符串
	cout << endl;

	//2. 获取file的后缀
	cout << "下方为2：" << endl;
	string file("string.cpp");
	size_t pos = file.rfind('.');	// pos缺省值为npos，是string里面的一个静态成员变量
									// static const size_t npos = -1; 由于为无符号数，实际为整形最大值，
									// 效果为从字符串最末尾开始往前找
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;
	cout << endl;

	//3. 取出url中的域名
	cout << "下方为3：" << endl;
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find(':'); //pos缺省值为0，从字符串第一个字符位置开始往后找
	if (start == string::npos) //find/rfind 未找到指定字符时 返回npos
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;
	cout << endl;

	//4. 删除url的协议前缀
	cout << "下方为4：" << endl;
	pos = url.find("://");
	url.erase(0, pos + 3); //删除
	cout << url << endl;
	cout << endl;
}

     2.5 非成员函数

上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。

三、OJ练习自测

  1. 仅仅反转字母

class Solution {
public:
    bool isLetter(char ch)
    {
        if(ch >='a' && ch <= 'z')
            return true;
        if(ch >= 'A' && ch <= 'Z')
            return true;

        return false;
    }
    string reverseOnlyLetters(string s) {
        if(s.empty())
            return s;
        size_t begin = 0;
        size_t end = s.size()-1;
        while(begin < end)
        {
            while(begin < end && !isLetter(s[begin]))
                ++begin;
            while(begin < end && !isLetter(s[end]))
                --end;

            swap(s[begin],s[end]);
            ++begin;
            --end;
        }
        return s;
    }
};

  2. 找字符串中第一个只出现的字符

class Solution {
public:
    int firstUniqChar(string s) {
        int count[128] = {0};
        for(int i = 0;i<s.size();i++)
        {
            count[s[i]]++; //s[i]会转换为ascll码值，具有唯一标识数
                           // i标识的是字符串的下标
        }
        for(int i = 0;i<s.size();i++)
        {
            if(count[s[i]] == 1)
                return i;
        }
        
        return -1;
    }
};

  3. 字符串最后一个单词长度

#include <iostream>
#include <string>
using namespace std;

int main() {
    string s;
    while(getline(cin, s)) //多组输入，题目要求不为空串，则为空时结束
    {
        size_t pos = s.rfind(' ');
        cout << s.size()-pos-1 << endl;
    }
   
    return 0;
}

  4. 验证回文串

class Solution {
public:
    bool IsLetterOrNumber(char ch)
    {
        if(ch>='A' && ch <='Z'
        || ch>='a' && ch<='z'
        || ch>='0' && ch<='9')
            return true;
        return false;
    }
    bool isPalindrome(string s) {
        for(auto& ch : s)
        {
            //将大写字符转为小写
            if(ch>='A' && ch<='Z')
                ch += 32;
        }
        //验证是否回文
        int begin = 0;
        int end = s.size()-1; //不能用size_t,串有可能为空，则为负数
        while(begin < end)
        {
            while(begin < end && !IsLetterOrNumber(s[begin]))
                ++begin;
            while(begin < end && !IsLetterOrNumber(s[end]))
                --end;
            if(s[begin] != s[end])
                return false;
            ++begin;
            --end;
        }

        return true;
    }
};

  5. 字符串相加

class Solution {
public:
    string addStrings(string num1, string num2) {
        string tmp;
        int cur1 = num1.size() - 1;
        int cur2 = num2.size() - 1;
        int next = 0;

        while (cur1 >= 0 || cur2 >= 0)
        {
            int x1 = cur1 >= 0 ? num1[cur1--]-'0' : 0;
            int x2 = cur2 >= 0 ? num2[cur2--]-'0' : 0;
            int sum = x1 + x2 + next;

            next = sum/10; //处理进位
            sum = sum % 10;

            //tmp.insert(0,1, sum + '0'); 头插时间复杂度为 N^2，则可先尾插再逆置
            tmp += (sum+'0'); 
        }
          
        if(next == 1) //最后一位为进位，要格外判断加上进位1
            tmp += '1';
            
        reverse(tmp.begin(), tmp.end());
        return tmp;
    }
};

四、string类的模拟实现

  0. 整体框架

//模拟实现string类
namespace Mystr //用命名空间封装，以免和std中的string冲突，调用方式如主函数
{
	class string
	{
	public:
		string(const char* str = "");
		string(const string& s);
		~string();
		string& operator=(string& s);
		const char* c_str() const;
	//...各类函数接口

	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
		//const static size_t npos = -1; √ 只有整型可以用缺省值
		//const static double npos = -1.0; ×
	};
}

int main()
{
	Mystr::string s1 = "abc"; //调用指定命名空间域的模拟string类
	s1.push_back('a');
	//...
	return 0;
}

  1. 构造 / 析构 / 拷贝 / 赋值

namespace bit
{
	const size_t string::npos = -1;
	
//1.0 构造（带参）
	/* V1版本 三个strlen效率低
	string::string(const char* str)
		:_str(new char[strlen(str) + 1])
		,_size(strlen(str))
		,_capacity(strlen(str))
	{
		strcpy(_str, str);
	}
	*/
	/* V2版本 忘记初始化列表初始化顺序=成员变量的声明顺序 
	string::string(const char* str)
		:_size(strlen(str))
		, _str(new char[_size + 1])
		, _capacity(_size)
	{
		strcpy(_str, str);
	}
	*/
	/* V3最终版 初始化列表与函数体内赋值 相结合 */
	string::string(const char* str)
		:_size(strlen(str))
	{
		_str = (new char[_size + 1]);
		_capacity = _size;
		strcpy(_str, str);
	}

//1.1 构造（无参）
	/* V1版本 不开空间× 
	string::string()
	{
		_str = nullptr;
		_size = _capacity = 0;
	}
	*/
	/*V2版本 无参和带参分开写
	string::string()
	{
		_str = new char[1]{ '\0' };
		_size = _capacity = 0;
	}
	*/
	/*V3版本 和构造带参V3版本一样，将全缺省和无参合二为一，声明处给缺省值即可*/

//1.2 拷贝构造（深拷贝，需要手动控制 开新空间）
	string::string(const string& s)
	{
		_str = new char[s._capacity];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	
//1.3 赋值运算符重载
	string& string::operator=(string& s)
	{
		if (this != &s)//判断是否为自己给自己赋值
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);
			delete[] _str;

			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}

//1.4 析构
	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
}

• 注释补充：

本文采用声明和定义分离的方式模拟string，注意事项如下（不分离的不用看）：
 ① 声明和定义都用命名空间域包起来防止冲突，链接时会自动合并（同名namespace）
 ② 定义时要指定类域，否则会报错（函数名前加string::）

     1.0 构造

思路：
 ① 开空间并赋值
 ② 更新_size，_capacity

问题（V1，V2版本）：

1. 多次使用strlen计算字符串长度，效率低
2. 如果想复用已经初始化好的，需要保证声明顺序，容易出错不建议这种做法
   （初始化列表初始化顺序 = 成员变量的声明顺序）

     1.1 构造（无参）

1. 是否要开空间？ --> 必须开
    流输出 cout 打印 const char* 指针类型，不会像其他指针一样 打印指针本身的值，而是去打印指针指向的内容（字符串），即默认发生解引用，会去找到‘/0’才停止。
    而此时未开辟空间，为空指针，对空指针解引用会出错
2. 可使用缺省参数将 全缺省和无参 合二为一
   ① 声明和定义分离：
    声明处写为 string(const char* str = ""); 定义处不变
   ② 不分离：
     定义处写

     1.3 赋值运算符重载

思路：
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_size，_capacity
优化：
 ① 判断是否为自己给自己赋值，自赋值时可不必开新空间

  2. 增 删 查 改

namespace bit
{
//5. c_str
	const char* string::c_str() const
	{
		return _str;
	}

//6. size
	size_t string::size() const
	{
		return _size;
	}
	
//7. find
	size_t string::find(char ch, size_t pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
				return i;
		}
	
		return npos;
	}

	size_t string::find(const char* sub, size_t pos)//查找子串
	{
		char* p = strstr(_str + pos, sub); 
		return p - _str; //指针加减运算
	}
	
//8. operator[]
	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}

	//const版本
	const char& string::operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}

//9. 迭代器（用指针模拟）
	typedef char* iterator;
	typedef const char* const_iterator;
	
	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}
	//const版本
	string::const_iterator string::begin() const
	{
		return _str;
	}
	string::const_iterator string::end() const
	{
		return _str + _size;
	}

//10. reserve
	void string::reserve(size_t n)
	{
		if (n > _capacity) //一般不缩容
		{
			char* tmp = new char[n + 1];//多开一个给'/0'
			strcpy(tmp, _str);
			delete[] _str;
.
			_str = tmp;
			_capacity = n;
		}
	}

//11. push_back
	void string::push_back(char ch)
	{
		if (_size + 1 > _capacity)
		{
			//赋值运算符优先级最低，先进行三目运算符判断，最后赋值
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
			//reserve(_size + 1); //需要多少开多少，也可以如上多开空间适用于多次插入的情景
		}
	
		_str[_size] = ch;
		_str[_size + 1] = '/0';
		++_size;
	}
	//复用insert 版本
	void string::push_back(char ch)
	{
		insert(_size, ch);
	}

//12. append
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
	
		//strcat(_str, str); 效率低，要从头开始遍历找'/0'位置
		strcpy(_str + len, str);
		_size += len;
	}
	//复用insert 版本
	void string::append(const char* str)
	{
		insert(_size, str);
	}

//13. operator+=
	string& string::operator+=(char ch) //字符
	{
		push_back(ch);
	
		return *this;
	}
	
	string& string::operator+=(const char* str)//字符串
	{
		append(str);
	
		return *this; //要适用于连续赋值情景，返回左操作数
	}

//14. insert
	void string::insert(size_t pos, char ch)
	{
		assert(pos < _size);
	
		if (_size + 1 > _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
	/* 若为头插，即pos == 0，需注意一下两种写法
	写法1：循环结束条件为end<0，end起始位置为size，将end位挪给end后一位
		注意：
			①将end写为int类型
			②强转size类型为int
		原因：
			设计上为while循环结束条件为 end < 0，即最后一次挪动为_str[1] = _str[0]，end--为-1，退出循环。
			但size_t为无符号整形，没有负数的概念，-1表示的是整形最大值，所以应该写为 注意①事项；
			且据C语言中所学，运算符两边操作数类型不同时，会发生类型提升：一般为类型小的向类型大的提升，
			int向size_t提升，所以用size赋值end时要写为 注意②事项
			
		//方法1 将end移向end后一位
		/*
		int end = _size; //end指向末尾位置'/0'位置，若指向有效字符的末字符位置，则会把'/0'覆盖掉，后续要手动加上
		while (end >= (int)pos)
		{
			_str[end + 1] = _str[end];
			--end;
		}
		*/
		//方法2 将end前一位移向end
		size_t end = _size + 1; //end指向'/0'后一位
		while (end >= pos-1)
		{
			_str[end] = _str[end - 1];
			--end;
		}
	
		_str[pos] = ch;
		++_size;
	}
	
	void string::insert(size_t pos, const char* str)
	{
		assert(pos < _size);
	
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
	
		//方法1 将end 移向 end+len位
		/*
		int end = _size;
		while (end >= (int)pos) //end > pos-1
		{
			_str[end + 1en] = _str[end];
			--end;
		}
		*/
		
		//方法2 将end-len 移向 end位
		size_t end = _size + len;
		while (end >= pos+len) //end > pos+len-1
		{
			_str[end] = _str[end - len];
			--end;
		}
	
		//memcpy(_str + pos, str,len); 都可以
		strcpy(_str + pos, str);
		_size += len;
	}

//15. erase
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
	
		// len大于后续字符个数时，有多少删多少
		if (len >= _size - pos)
		{
			_str[pos] = '/0'; //直接置'/0'
			_size = pos;
		}
		else
		{
			//移动覆盖
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}
//16. substr
	string string::substr(size_t pos, size_t len)
	{
		// len大于后面剩余字符，有多少取多少
		if (len > _size - pos)
		{
			string sub(_str + pos);
			return sub;
		}
		else
		{
			string sub;
			sub.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				sub[i] = _str[pos + i];
			}
	
			return sub;
		}
	}
}

//迭代器测试函数
void test_string2()
{
	string s3("hello world");
	for (auto ch : s3)
	{
		cout << ch << " ";
	}
	cout << endl;

	string::iterator it3 = s3.begin();
	while (it3 != s3.end())
	{
		cout << *it3 << " ";
		++it3;
	}
	cout << endl;
}

     2.0 迭代器

注意：
 ① 重载一般版本和const版本

     2.1 reserve

思路：
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_str，_capacity
注意：
 ① 一般不缩容，给定空间比现有空间小时，不变化

     2.2 push_back / append / operator+= / insert

思路：
 ① 检查容量（扩容）
 ② 插入
 ③ 更新
注意：
 ① 实现 insert 即可复用于 => push_back / append => +=
 ② 重载插入字符 和 字符串两个版本
 ③ insert 中 while循环的两种写法（‘/0’位 移向后一位，'/0’前一位移向 '/0’位）
 ④ 结束条件写法（> / >=）
  ① > x 时，=x-1时 为最后一次进入循环
  ② >= x 时，=x时 为最后一次进入循环
  ③ <= x 时，=x时 为最后一次进入循环

     2.3 erase

思路：
 分两种情况，一为有多少删多少，二为删除指定位后指定个
 1. 直接在pos位 置’/0’ 并更新_size（相当于删除后续所有字符）
 2. 将指定位后的字符 移动覆盖到 pos位后

     2.4 substr

思路：
 分两种情况，一为有多少取多少，二为取指定位后指定个 为子串
 1. 直接用pos位的 指针构造子串（字符串指针指向首字符位置，相当于传入子串的指针）
 2. 从pos位开始，依次将指定个 赋值给新串

  3. 非成员函数

namespace bit
{
	const size_t string::npos = -1;
//17. swap
	// s1.swap(s2)
	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	
//18. 各类运算符重载
	bool string::operator<(const string& s)const
	{
		return strcmp(_str, s._str) < 0;
	}
	
	bool string::operator==(const string& s)const
	{
		return strcmp(_str, s._str);
	}
	
	bool string::operator>(const string& s) const
	{
		return !(*this <= s);
	}
	
	bool string::operator>=(const string& s)const
	{
		return !(*this < s);
	}
	
	bool string::operator<=(const string& s) const
	{
		return *this < s || *this == s;
	}
	
	void string::clear()
	{
		_str[0] = '/0';
		_size = 0;
	}
	
	/*V1版本 
	istream& operator>>(istream& is, string& str)
	{
		str.clear();
		char ch;
		//cin >> ch; 无法读取含空格的串
		ch = is.get();
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
	
		return is;
	}*/
	
	/*V2版本 模拟缓冲区*/
	istream& operator>>(istream& is, string& str)
	{
		char buff[128];
		int i = 0;
		char ch = is.get();
		while (ch != ' ' && ch != '/n') 
		{
			buff[i++] = ch;
	
			if (i == 127)
			{
				buff[i] = '/0';
				str += buff; //数组名就是数组首元素的指针
				i = 0;
			}
	
			ch = is.get();
		}
	
		if (i != 0)
		{
			buff[i] = '/0';
			str += buff;
		}
	
		return is;
	}
		
	ostream& operator<< (ostream& os, const string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			os << str[i];
		}
	
		return os;
	}
}

     3.0 npos

注意：
 ① 为静态成员变量，类内声明 类外定义，相当于全局变量
  【若整体声明和定义分离则需要在 .h 文件中声明，.cpp 文件中定义，避免多个源文件包含.h 时发生重定义】
 ② 一般不能在声明处给缺省值（给缺省值实际是给初始化列表使用的，而静态成员变量不走初始化列表）

• 特例： const static int/size_t 类型变量 可以使用缺省值初始化

     3.1 swap

思路：
  手动交换各自的成员变量即可
问题：
  为什么std中含有 swap，string中还要再提供？又为什么提供两个？
  ① std中的 swap为模板（如上图三），代价太大（需要一次拷贝构造，两次赋值，反复开辟、释放空间）
  ② string的成员函数swap是 针对string类对象的优化写法，而非成员函数swap 是设计者怕使用者直接调用std中的模板，手动对该模板进行的实现（有现成的用现成的），其内部实际上还是调用的成员函数swap（套娃）。

string s1, s2;
s1.swap(s2); //调用成员函数 swap
swap(s1, s2); //调用非成员函数 swap（如果没有对模板中的string类型 进行实现为非成员函数，则会调用std中的模板）

     3.2 比较运算符重载

注意：
 ① 只需实现 operator<，operator== （用strcmp模拟），其余均可复用实现

     3.3 流提取（>>）

注意：
 ① cin 无法提取含空格的串，如“abc d”只能提取到 abc（因为空格和换行默认为多个值之间的分隔符），此时要使用 istream类中的函数get代替cin
 ② 流提取具有覆盖效果，此处模拟实现clear进行
优化：
 模拟缓冲区，使用buff数组避免频繁扩容（每127个字符扩一次容）
  ① 每127个字符后添加 ‘/0’（处理刚好为127倍数长度的串）
  ② 循环结束后 i ≠ 0时，添加’/0’（处理不为127倍数长度的串）

  4. 传统写法与现代写法

上文模拟实现部分就是传统写法，核心思想为自己动手做，而现代写法主要体现了复用的思想，让别人干活，交换

     4.1 拷贝构造

//现代写法 s2(s1)
string::string(const string& s)
{
	string tmp(s._str); //让构造干活
	swap(tmp); //交换成员
}

思路：

1. 复用构造，构造与s1内容一致的tmp
2. 将s2与s1 交换成员
    ① s2声明后未初始化，指向随机值，将tmp与s2交换类成员，s2得到了想要的拷贝效果
    ② 而tmp为局部变量，出作用域会调用析构函数自动销毁

     4.2 赋值运算符重载

//s1 = s3
	/*V1版本*/
string& string::operator=(const string& s)
{
	if (this != &s)
	{
		//string tmp(s);
		string tmp(s._str);
		swap(tmp);
	}

	return *this;
}
	/*V2 版本（代码量减少，但效率不变）*/
string& string::operator=(string tmp) //调用拷贝构造tmp(s3)
{
	swap(tmp);

	return *this;
}

思路：

1. 复用构造 / 拷贝构造，构造与s3内容一致的tmp
2. 将s1与 tmp 交换成员
    ① tmp与s1交换类成员，s1得到了想要的拷贝效果
    ② 而tmp为局部变量，出作用域会调用析构函数自动销毁

五、扩展阅读

  5.1 写时拷贝

引入情景：
 深拷贝效率低，对浅拷贝进行优化处理 使之能使用

浅拷贝问题与解决：

1. 析构多次（同一块空间，不同的对象）
   => 引用计数：不为1时，计数- -
         为1时，即最后一个对象，此时才释放空间
2. 一个修改影响另一个
   => 写时拷贝：进行修改的才走深拷贝开辟空间，否则走浅拷贝共用空间（核心：不修改就赚了）

  5.2 vs和g++下string结构的说明

注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。

• vs下string的结构
  string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：
  • 当字符串长度小于16时，使用内部固定的字符数组来存放
  • 当字符串长度大于等于16时，从堆上开辟空间

union _Bxty
{ 	
	value_type _Buf[_BUF_SIZE];
	pointer _Ptr;
	char _Alias[_BUF_SIZE]; 
} _Bx;

这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
最后：还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节。

• g++下string的结构
  G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：
  • 空间总大小
  • 字符串有效长度
  • 引用计数
  • 指向堆空间的指针，用来存储字符串

struct _Rep_base
{
	size_type _M_length;
	size_type _M_capacity;
	_Atomic_word _M_refcount;
};

总结

本文介绍了string类的常用接口，并对其中重点接口进行了模拟实现，以便读者了解其底层逻辑，有利于更好地使用。
尽管文章修正了多次，但由于水平有限，难免有不足甚至错误之处，敬请各位读者来评论区批评指正。