【C++STL】新手也能会：string 模拟实现保姆级指南！

//无参的默认构造
string::string()
	:_str(new char[1]{'\0'})
	,_size(0)
	,_capacity(0)
{}
//带参的构造
string::string(const char* str)
	:_size(strlen(str))
//,_size(strlen(str))
//,_capacity(strlen(str))
{
	cout << "构造" << endl;
	_capacity = _size;
	_str = new char[_size+1];//开跟str一样大的空间 还要加1 给\0预留空间 
	memcpy(_str, str, _size+1);
}

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

//拷贝构造 
string::string(const string& s)
{
	//开辟新空间
	_str = new char[s._capacity+1];
	//拷贝旧数据
	memcpy(_str, s._str, s._size+1);
	_size = s._size;
	_capacity = s._capacity;
}

string& string::operator=(string& s)
{
	//防止给自己赋值
	if (this != &s)
	{
		//开新空间拷贝旧数据
		char* tmp = new char[s._size + 1];
		memcpy(tmp, s._str, s._size + 1);
		delete[] _str;
		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}

//string的迭代器 底层使用char*来实现
typedef char* iterator;
typedef const char* const_iterator;

iterator begin();
iterator end();

//cosnt迭代器
const_iterator begin() const;
const_iterator end() const;

//普通迭代器
string::iterator string::begin()
{
	//返回首元素 头指针
	return _str;
}
string::iterator string::end()
{
	//返回尾指针 
	return _str + _size;
}

//const迭代器
//这里修饰的就是this指针
string::const_iterator string::begin() const
{
	return _str;
}
string::const_iterator string::end() const
{
	return _str + _size;
}

size_t string::size() const
{
	return _size;
}

void string::clear()
{
	_str[0] = '\0';
	_size = 0;
}

void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		//扩容逻辑：先根据n重新开一块空间 然后将旧数据拷贝到新空间 释放旧空间 
		char* tmp = new char[n+1];
		memcpy(tmp, _str, _size+1);
		delete[] _str;
		_str = tmp;//指向新空间
		_capacity = n;
	}
}

//尾插
void string::push_back(char ch)
{

	//所有的插入都要先判断空间是否足够
	if (_size >= _capacity)
	{
		//扩容 直接扩二倍
		size_t newcapacity = 0 ? 4 : 2 * _capacity;
		reserve(newcapacity);
	}
	//空间足够直接在_size位置处插入
	_str[_size] = ch;
	_size++;
	//处理\0
	_str[_size] = '\0';
}

//追加一个字符串
void string::append(const char* str)
{
	size_t len = strlen(str);
	if (len+_size>=_capacity)
	{
		//扩容
		size_t newcapacity = 2 * _capacity > len + _size ? 2 * _capacity : len + _size;
		reserve(newcapacity);	
	}
	memcpy(_str + _size, str, len+1);//拷贝len+1个 给\0预留空间
	_size += len;
}

//加等直接调用对应的函数
string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}

string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

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

//从pos位置处查找一个字符
size_t string::find(char ch, size_t pos) const
{
	assert(pos < _size);
	for (size_t i = pos;i < _size;i++)
	{
		if (_str[i] == ch)//这里注意不能写'ch' ch本身就是一个字符变量
		{
			return i;
		}
	}

	return npos;

}
//从pos位置处查找一个字符串
size_t string::find(const char* str, size_t pos)  const
{
	assert(pos < _size);
	//底层使用strstr来实现
	const char* p1 = strstr(_str + pos, str);//p1是_str加上字串的起始位置
	if (p1 == nullptr)
	{
	//如果在_str中找不到一个具体的下标 就返回整型的最大值npos
		return npos;
	}
	else
	{
	//p1-_str就是子串的起始位置 
		return p1 - _str;
	}
}

//截取子串
string string::substr(size_t pos, size_t len) const
{
	//同样分成两种情况 一种是直接截取完 一种是截取一部分
	if (pos == npos || _size - pos <= len)
	{
		len = _size - pos;//pos到_size之间 总共就只有len个长度的数据
	}
	string ret;
	ret.reserve(len);
	for (size_t i = 0;i < len;i++)
	{
		ret += _str[i + pos];
	}
	//传值返回 所以需要拷贝构造
	return ret;
}

char& string::operator[](size_t i)
{
	//返回底层字符数组的第i个字符
	assert(i < _size);
	return _str[i];
}

const char& string::operator[](size_t i) const
{
	//加了const修饰 只读
	assert(i < _size);
	return _str[i];
}

ostream& operator<<(ostream& out, const string& s)
{
	//注意这里不能直接调用c_str 因为c_str返回原生的char* 碰到\0就停止了 
	//如果我们往string后面插入了\0那就是大坑了 会出现乱码
	//out << s.c_str();

	//所以要一个一个的输出 
	for (size_t i = 0;i < s.size();i++) //这里传的是const sting 如果size()接口
										//没有加上const 那么const string是调用不了的
	{
		out<<s[i];
	}
	return out;
}

istream& operator>>(istream& in, string& s)
{
	//为了避免插入之前对象的内容会与我们输入的内容重合 
	//在提取之前先清空一下
	s.clear();

	char buff[128];//中转站 这样可以减少扩容的次数
	int i = 0;
	char ch = in.get();//cin与scanf一样碰到空格就自动结束提取了 
						//所以这里使用get接口能够获取到空格换行等
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[i] = '\0';
			//满127就加等到s上
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	if (i > 0)
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;
}