【STL源码剖析】string类模拟实现 了解底层-走进底层-掌握底层【超详细的注释和解释】

博主对大家的话

从今天开始，STL源码剖析的专栏就正式上线了！其实在很多人学习C++过程中，都是只学习一些STL的使用方式，并不了解底层的实现。博主本人认为，这样的学习这样的技术是不深的。如果我们想要熟悉的掌握一门语言，我认为，底层的实现必不能少！
但是，想从0开始模拟实现STL的容器，需要我们熟悉C++的语法，特别是类和对象部分的知识！
博主学习C++到现在，我认为C++类和对象基本语法的学习比任何部分都要重要，而我花在这上面的时间也是最多的！只要搞清楚C++面向对象编程的基本规则，我们才能在STL的世界里游刃有余！
所以我希望大家在学习STL之前，先将数据结构与算法，C++的类和对象部分内容掌握熟悉！

前言

那么这里博主先安利一下一些干货满满的专栏啦！

数据结构专栏：数据结构 这里包含了博主很多的数据结构学习上的总结，每一篇都是超级用心编写的，有兴趣的伙伴们都支持一下吧！
STL源码剖析专栏：STL容器的模拟实现 以STL源码为基础，模拟实现STL的各种容器。从底层开始，一步一步解密STL。掌握底层，才是真正学会STL
算法专栏：算法
力扣刷题专栏：Leetcode
C的深度解剖专栏：C语言的深度解剖
**

实现过程一些要注意的点

因为STL库里面的string其实是很多年发展出来的类，里面一共有106个成员函数。
在这里面其实并不是每一个我们都要去实现的，我们要去实现的其实是一些重要的，必备的，有代表性的功能。其实关于string类发展到现在这么久，其实很多人对它有很多不同的评价，这里博主分享一篇文章。

• STL 的string类怎么啦？https://blog.csdn.net/haoel/article/details/1491219

因此，在博主的模拟实现中，只提供了STL中的部分接口，但是这些，对于在初学阶段来说，足够了！
对于实现过程的一些细节问题，博主会在源代码的注释中指出！

STL中string类模拟实现

#pragma once
#include
#include
#include
using namespace std;


//为了区分和库里面的，我们用命名空间包起来
namespace MyString {
	class string {
	public:
		//迭代器和const迭代器
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin() {
			return _str;
		}
		iterator end() {
			return _str + _size;
		}
		//const迭代器 -- 只读不写
		const_iterator begin() const {
			return _str;
		}
		const_iterator end() const {
			return _str + _size;
		}
		//构造
#if false
		string()//初始化的时候一定不能给nullptr，因为如果创建一个空对象的时候，去打印
			//就会造成空指针的解引用
			//或者给全却称
			:_str(new char[1]),
			_size(0),
			_capacity(0)
		{
			_str[0] = '\0';//给一个空间放'\0'
		}
#endif
		string(const char* str = "\0")//写""是等价的，因为""会自带'\0'
			//:_str(new char[strlen(str) + 1]),
			//_size(strlen(str)),
			//_capacity(strlen(str)) -- 这样搞用三次strlen() -- 别用初始化列表了
		{
			//动态开辟空间
			size_t len = strlen(str);
			_str = new char[len + 1];
			_size = len;
			_capacity = len;
			strcpy(_str, str);
		}
		//析构
		~string() {
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
		//拷贝构造(实现一个深拷贝)		
		//写法1：传统写法
#if 0
		string(const string& s) 
			:_str(new char[s._capacity+1]),
			_size(s._size),
			_capacity(s._capacity)
		{
			strcpy(_str, s._str);
		}

		//赋值重载
		string& operator=(const string& s) {
			if (this == &s)return *this;//自己给自己赋值 -- 直接避开
			//无论什么情况，都选择把原来的空间释放掉+开新的空间+拷贝
			char*tmp = new char[s._capacity + 1];//一定要记得+1
			//new失败怎么办 -- 这样就会造成拷贝失败，而且原来的string被释放了，所以最好先new再delete原来的
			strcpy(tmp, s._str);
			delete[] _str;

			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
			return *this;
			//这样写的话，自己给自己赋值就会出问题 -- 因为自己给自己释放了 -- 拷贝自己 -- 拷贝到的就是随机值！
		}
#endif
		//现代写法
		//构造来当打工人
		void swap(string& tmp) {
			std::swap(_str, tmp._str);
			std::swap(_size, tmp._size);
			std::swap(_capacity, tmp._capacity);
		}
		string(const string& s)
			: _str(nullptr),
			_size(0),
			_capacity(0)
		{
			//因为s里面的东西可能是随机值
			//如果换给tmp之后，tmp出了作用域是会析构的 -- 析构随机的东西就会出问题
			//析构0或者null是不会出问题的，所以初始化一下
			//因为swap要频繁调用，我们这里自己再写一个最好
			string tmp(s._str);
			swap(tmp);//this->swap(tmp)
		}
		//写法2：
#if 0
		string& operator=(const string& s) {
			if (this == &s)return *this;//自己给自己赋值 -- 直接避开
			string tmp(s);
			swap(tmp);//this和swap换
			return *this;
			//把原来的s换给tmp之后 -- tmp还需要帮忙打扫s的空间，因为tmp是一个局部对象！
		}
#endif
		//写法3
		string& operator=(string s) {//s就是顶替tmp，s就完成拷贝了，而且是局部对象！
			swap(s);
			return *this;
		}
		//在以后复杂数据结构的学习中 -- 现代写法的优势会更大
		
		
		//size
		size_t size()const {
			return _size;
		} 
		size_t capacity()const {
			return _capacity;
		}
		//[]重载
		char& operator[](size_t pos) {
			assert(pos < _size);
			return _str[pos];
		}
		char& operator[](size_t pos) const { //这个是不能写的
			assert(pos < _size);
			return _str[pos];
		}
		//兼容C字符串接口
		const char* c_str() {
			return _str;
		}
		void reserve(size_t n) {
			if (n > _capacity) {
				//扩容不缩容
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;

				_str = tmp;
				_capacity = n;
			}
		}
		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;
			}
		}
		void push_back(char ch) {
			//不用去写CheckCapacity函数，我们先写reserve这个函数，复用！
#if 0
			if (_size==_capacity)
			{
				//注意：如果一开始是用了构造的缺省值，也就是0，就不能扩二倍！
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';//一定要记得'\0'
#endif
			insert(_size, ch);
		}
		void append(const char* str) {
#if 0
			size_t len = strlen(str);
			if (_size + len > _capacity)//注意，此时不能扩容二倍了！因为可能不够
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);//哪个好？
			//strcat(_str, str);//这个效率是比较低的 -- 因为要去strcat要去找'\0',持续追加的时候效率非常低！
			_size += len;
#endif
			insert(_size, str);
		}
		string& operator+=(char ch) {
			push_back(ch);
			return *this;
		}
		string& operator+=(const char* str) {
			append(str);
			return *this;
		}
		//insert
		string& insert(size_t pos, char ch) {
			assert(pos <= _size);
			if (_size == _capacity) {
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			//pos==0情况第一种处理方法
#if 0
			int end = _size;
			while (end >= (int)pos) {
				//注意：pos==0的时候会出问题，end--之后会变成-1->整型最大值，所以给pos强转一下,_size改成int就行
				_str[end + 1] = _str[end];
				--end;
			}
#endif
			//第二种处理方法(比较推荐)
			size_t end = _size + 1;//这些都别改，继续用uint
			while (end > pos)//这里写成大于！
			{
				_str[end] = _str[end - 1];//这里改成-1
				--end;
			}
			_str[pos] = ch;
			++_size;
			return * this;
		}
		//实现这些接口一定要很细心很细心！
		string& insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity) {
				reserve(_size + len);
			}
			//挪动数据
			size_t end = _size + len;//这些都别改，继续用uint
			while (end >= pos + len)//这里写成大于！
			{
				_str[end] = _str[end - len];//这里改成-1
				--end;
			}
			//放数据
			strncpy(_str + pos, str, len);//这里用ncpy，不要把'\0'拷贝进去
			_size += len;
			return *this;
		}
		//erase
		string& erase(size_t pos, size_t len = npos) {
			assert(pos < _size);
			if (len == npos || pos + len >= _size) {
				//相当于pos后面的全部删掉了
				_str[pos] = '\0';
				_size = pos;
			}
			else {
				//删除部分
				//需要挪动数据
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}
		void clear() {
			_str[0] = '\0';
			_size = 0;
		}
		//find系列
#if true
		size_t find(char ch, size_t pos = 0) {
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++) {
				if (ch == _str[i]) {
					return i;
				}
				return npos;
			}
		}
		size_t find(const char* sub, size_t pos = 0) {
			//strstr -- 暴力
			//字符串匹配算法 kmp/bm
			assert(pos < _size);
			assert(sub);
			const char* ptr = strstr(_str + pos, sub);
			if (ptr == nullptr) {
				return npos;
			}
			return ptr - _str;
		}
		//substr --  从pos位置开始，取len个字符
		string substr(size_t pos = 0, size_t len = npos)const {
			//不用改变自己，const也行
			assert(pos < _size);
			size_t realLen = len;
			if (len == npos || pos + len > _size) {
				//超范围了
				//有多少取多少
				realLen = _size - pos;
			}
			string sub;
			for (size_t i = 0; i < realLen; ++i) {
				sub += _str[pos + i];
			}
			return sub;
		}
#endif
		//运算符重载比较系列
#if true
		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);
		}
#endif
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	public:
		//这个npos按道理在外面也可以取到才对
		const static size_t npos = -1;
	};
	//流提取和流插入
	//不是必须是友元的，因为不一定要访问私有，这里就不用
	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) {

		s.clear();

		//输入字符串很长，不断+=，频繁扩容，效率很低，大家可以想办法优化一下
		//1.reserve() -- 缺陷：浪费空间
		//2.别动string先，先放到一个临时数组里面，因为这个临时数组是在栈上的 -- 出了>>就销毁了
		char ch;
		ch = in.get();

		const size_t N = 32;
		char buff[N];
		size_t i = 0;

		//s.reserve(128);
		while (ch != ' ' && ch != '\n') {
			buff[i++] = ch;
			if (i == N - 1) {//表示满了
				buff[i] = '\0';
				s += buff;//一批一批加到string里面
				i = 0;
			}
			ch = in.get();
		}
		//把最后一批加上去
		//buff相当于缓冲了
		buff[i] = '\0';
		s += buff;
		return in;
		//但是现在会有bug
		//如果字符串里面原来有东西的话，会留下
		//我们先要清空一下string
	}
	//size_t string::npos = -1;//在类外面定义
	//但是const static变量可以在类里面给缺省，外面就不用写了，这是C++的特例
}

尾声

看到这里，相信大家对string类的模拟实现已经有一定的了解了！string的模拟实现，知识我们掌握STL的开始，后面，博主将会给大家带来vector，list等等STL容器的模拟实现，持续关注，订阅专栏，点赞收藏都是我创作的最大动力！

( 转载时请注明作者和出处。未经许可，请勿用于商业用途 )
更多文章请访问我的https://blog.csdn.net/Yu_Cblog?type=blog