因此reserve函数的实现逻辑与以前实现的增容逻辑没有变化，都是开辟新空间，并拷贝内容，然后释放旧空间。

        void reserve(size_t n)//开辟空间
		{
			if (n > _capacity)//
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

        而resize函数就需要分情况来讨论，当n大于capacity时复用reserve进行空间开辟，并将新拓展的空间初始化为'\0'；当n小于capacity时我们需要将空间缩小，实际就是控制size的大小。

		void resize(size_t n, char ch = '\0')//开辟空间加初始化
		{
			if (n > _size)//增加数据
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
			else//删除数据
			{
				_str[n] = '\0';
				_size = n;
			}
		}

4.迭代器的实现

        迭代器是容器中一种类似于指针访问元素的工具，但是迭代器并不是指针。对于空间连续的string类和vector类我们可以使用指针直接实现迭代器，但是对于空间不连续的链表来说，迭代器就不能使用原生指针。

        迭代器一般会提供begin，end，rbegin，rend等函数接口。begin，end等接口还分为只读类型的const_iterator。

        //迭代器---指针
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const typedef char* const_iterator;
		const_iterator begin()const
		{
			return _str;
		}
		const_iterator end()const
		{
			return _str + _size;
		}

5.插入与删除函数

        string类中对于字符的插入与删除提供的接口也很多，但是常用的接口却不多，+=操作符的重载最常用，该操作符可以实现对字符，字符串，string类进行+=操作。在实现+=运算符时，可以先实现push_back，append等函数，然后复用这些函数进行实现。

5.1push_back与pop_back

        push_back，pop_back函数就是在末尾增减一个字符，与顺序表实现的逻辑一样。

		void push_back(char ch)//插入
		{
			if (_size == _capacity)//检查空间是否足够
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		void pop_back()
		{
			assert(_size > 0);
			_size--;
			_str[_size] = '\0';
		}

        值得注意的一点是无论插入还是删除，都需要重新在字符串后面显示添加'\0'作为字符串结束标记。 

5.2append与+=

        append函数实现的重载比较多，但是常用的并不多。通常使用都是对字符串的增加操作。

        对于使用append增加一个字符串，我们首先需要知道字符串的长度，然后检查剩余容量是否能够容纳新增字符串的长度，如果不能还需要扩容处理。剩下的就是将字符连接到原先字符串的后面即可，我们可以使用strcpy函数进行操作。

	    void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size+len > _capacity)
			{
				reserve(_size+len);
			}
			strcpy(_str + _size, str);
			//strcat(_str , str);//效率低，因为要遍历找'\0'
			_size += len;
		}

        这里需要注意，很多人再想到字符串连接时需要使用strcat函数，这样使用是没有问题的，与strcpy函数一样：strcat(_str+_size,str);但是如果我们这样使用效率会很低： strcat(_str,str);原因在于strcat需要从头寻找 '\0' 浪费时间。

        在append实现字符串的插入后，就可以顺手实现两个重载函数。

		//插入一个string类
        void append(const string& s)
		{
			append(s._str);
		}
 
        //插入n个字符
		void append(size_t n, char ch)
		{
			reserve(_size + n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(ch);
			}
		}

        对于+=操作符的实现，就是将push_back与append进行了合并。

        string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		string& operator+=(const char* ch)
		{
			append(ch);
			return *this;
		}
		string& operator+=(const string s)
		{
			append(s);
			return *this;
		}

5.3insert与erase

        insert函数库中也提供很多的重载版本，我们只需要模拟实现常用的即可。insert函数的逻辑就是在pos位置之前插入字符或者字符串。

        在模拟实现时我们还是需要先检查pos是否符合条件，并且判断空间是否够用。在满足这些条件后就需要对pos及pos之后的元素向后移动，将pos指向的空间空出来，然后插入新字符。

		string& insert(size_t pos, char ch)//插入字符
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}
			size_t end = _size + 1;
			while (end>pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			++_size;
			return *this;
		}

插入过程如下所示： 

        而对于插入n个字符的insert就需要先移出n个字符的位置出来，但是我们需要先对n进行判断，如果n等于0，则说明没有插入，直接返回即可，不然将会出现错误。移动完毕后将字符插入进去即可。而插入一个字符串就可以先计算出字符串的长度，然后与插入n个字符时一样挪动数据即可。

        string& insert(size_t pos, size_t n, char ch)//插入n个字符
		{
			assert(pos <= _size);
			if (n == 0)//插入0个字符
			{
				return *this;
			}
			if (_size+n > _capacity)
			{
				reserve(_size+n);
			}
			size_t end = _size + n;
	
			while (end>= pos+n)
			{
				_str[end] = _str[end-n];
				--end;
			}
			while (pos <= end)
			{
				_str[pos] = ch;
				++pos;
			}
			_size += n;
			_str[_size] = '\0';
			return *this;
		}
        string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (len == 0)//极端情况插入空串
			{
				return *this;
			}
			if (_size+len > _capacity)
			{
				reserve(_size+len);
			}
			size_t end = _size + len;
			while (end>=pos+len)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}
 

        erase函数我们只需要实现删除pos位置开始后的n个字符即可，如果n大于字符串长度时则将后面的字符全部删除。

删除时我们使用strcpy函数进行了覆盖。

	    void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
		}

6.find与substr函数

        find函数在string类中给出了，但是在库中还有一个全局的find函数。

        string类中提供的find函数在找到时返回的是字符的下标或者字符串首字母的下标，找不到返回的是npos。

        查找字符我们只需要遍历然后比对即可，找到就返回下标，找不到返回npos，而对于字符串的查找，可以复用库函数strstr，只不过strstr找到返回字符串的指针，找不到返回的是nullptr。

		size_t find(const char ch, size_t pos = 0)const 
		{
			assert(pos < _size);
			size_t i = 0;
			for (i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}
			return npos;
		}
		size_t find(const char* sub, size_t pos=0)const
		{
			assert(sub);
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, sub);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

        有时我们还需兼顾C语言的环境，C语言中没有string类，只有字符串，因此我们还需要实现接口c_str。

		const char* c_str()const
		{
			return _str;
		}

        substr函数是取出string类中pos之后的n个字符的函数，当n没有显示提供或者大于size时，则将pos之后的字符全部取出并存放在string类中，然后返回。

		string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			size_t realen = len;
			if (len == npos || len + pos > _size)
			{
				realen = _size - pos;
			}
			string ret;
			for (size_t i = 0; i < realen; i++)
			{
				ret += _str[pos + i];
			}
			return ret;
		}

7.运算符重载

        运算符的重载没有什么难点，和日期类一样，只需要实现==和>运算符的重载后其他的进行复用实现即可。

        bool operator>(const string& s) const
		{
			return strcmp(_str, s._str)>0;
		}
		bool operator==(const string& s) const
		{
			return strcmp(_str, s._str) == 0;
		}
		bool operator >=(const string& s)const
		{
			return *this > s || *this == s;
		}
		bool operator <(const string& s)const
		{
			return !(*this >= s);
		}
		bool operator <=(const string& s)const
		{
			return !(*this > s);
		}
		bool operator !=(const string& s)const
		{
			return !(*this == s);
		}

        而运算符重载中稍微需要注意的就是流提取和流插入运算符的重载，这两个需要在类外进行实现，但不一定非要设计成string类的友元函数，例如我们将string类在命名空间lb中实现，那我们在使用string类时需要指定命名空间lb，将流提取函数实现为lb空间中的全局函数也可以进行操作。

        流插入运算符中我们需要考虑效率问题，为了避免频繁的插入，我们需要实现一个类似缓冲区的容器进行临时存放函数。并且插入字符时通常用空格或者'\r'来作为间隔符，cin是不识别这两个字符的，因此我们需要使用istream中的接口函数get()。

	ostream& operator<<(ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}
		return out;
	}
	//istream& operator>>(istream& in, string& s)//频繁扩容
	//{
	//	char ch = in.get();
	//	while (ch != ' ' && ch != '\n')
	//	{
	//		s += ch;
	//		ch = in.get();
	//	}
	//	return in;
	//}
	istream& operator>>(istream& in, string& s)//
	{
		s.clear();//清除原有字符
		char ch = in.get();
		const size_t N = 32;
		char buff[N];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == N - 1)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
 
			}
			ch = in.get();
		}
		buff[i] = '\0';
		s += buff;
		return in;
	}

总结

        string类的模拟实现并不难，就是一些基础知识的复用与堆叠，博主实现的string类仅仅是简单的练习版本，函数接口的实现仁者见仁智者见智，大家可以根据自己的想法进行模拟实现。代码链接：完成string的模拟实现 · 5b291e4 · 冰冰棒/C++ - Gitee.com

        在拷贝构造和赋值重载时还有一种拷贝方式可以实现，即写时拷贝，有兴趣的可以观看其他博主的文章进行欣赏。