C++：string的的模拟实现

hello，各位小伙伴，本篇文章跟大家一起学习《C++：string的的模拟实现》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！
如果本篇文章对你有帮助，还请各位点点赞！！！

话不多说，开始进入正题

🍁💓

💓模拟实现string头文件

#pragma once
#include<iostream>
#include<assert.h>

using namespace std;

namespace My_string
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin();
		iterator end();

		const_iterator begin() const;
		const_iterator end() const;

		//string();
		string(const char* str = "");
		string(const string& s);
		string& operator=(string s);
		~string();

		const char* c_str() const;

		size_t size() const;
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;

		void reserve(size_t n);

		void push_back(char ch);
		void append(const char* str);

		string& operator+=(char ch);
		string& operator+=(const char* str);

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		void erase(size_t pos = 0, size_t len = npos);

		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);

		void swap(string& s);
		string substr(size_t pos = 0, size_t len = npos);

		bool operator<(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator==(const string& s) const;
		bool operator!=(const string& s) const;
		void clear();

	private:
		// char _buff[16];
		char* _str = nullptr;

		size_t _size = 0;
		size_t _capacity = 0;
		const static size_t npos;
	};
	istream& operator>> (istream& is, string& str);
	ostream& operator<< (ostream& os, const string& str);
}

1.🍁iterator begin();和iterator end();🍁const_iterator begin() const;和const_iterator end() const;

之前说过iterator是个类指针的工具，所以我们在这里用指针的方式模拟：

string:: iterator string::begin()
{
	return _str;
}

string::iterator string::end()
{
	return _str + _size;
}

string::const_iterator string::begin() const
{
	return _str;
}
string::const_iterator string::end() const
{
	return _str + _size;
}

2.🍁构造函数和拷贝构造函数

🍃构造函数

string::string(const char* str)
	:_size(strlen(str))
{
	_str = new char[_size + 1];
	_capacity = _size;
	strcpy(_str, str);
}

🍃拷贝构造函数

这里复用构造函数：

string:string(const string& s)
{
	string tmp(s._str);
	swap(tmp);
}

3.🍁析构函数

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

4.🍁赋值重载函数

🍃传统写法：

string& string::operator=(const string& s)
{
	if(this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp,s._str);
		delete[] _str;
		_size = s._size;
		_capacity = s._capacity;
		_str = tmp;
	}
	return *this;
}

🍃现代写法：
这里用传值传参，形成一个实参的临时拷贝，也就是复用了拷贝构造函数：

string& string::operator=(string s)
{
	swap(s);// 让别人来干活
	return *this;
}

5.🍁const char* c_str() const;

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

6.🍁size_t size() const;

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

7. 🍁[]运算符重载

🍃char& operator[](size_t pos);

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

🍃const char& operator[](size_t pos) const;

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

8.🍁void reserve(size_t n);

void string::reserve(size_t n)
{
	if (_capacity < n)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp,_str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

9.🍁void push_back(char ch);

🍃在实现insert之前的写法：

void string::push_back(char ch)
{
	if(_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : 2*_capacity;
		reserve(newcapacity);
	}
	_str[_size] = ch;
	_str[_size + 1] = '\0';
	++_size;
}

🍃在实现insert之后的写法：

void string::push_back(char ch)
{
	insert(_size,ch);
}

10.🍁void append(const char* str);

🍃在实现insert之前的写法：

void string::append(const char* str)
{
	size_t len - strlen(str);
	if(_size + len >= _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : 2*_capacity;
		reserve(newcapacity);
	}
	strcpy(_str + _size, str);
	_size += len;
}

🍃在实现insert之后的写法：

void string::append(const char* str)
{
	insert(_size,str);
}

11.🍁+=运算符重载函数

🍃string& operator+=(char ch);

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

🍃string& operator+=(const char* str);

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

12.🍁insert的实现

🍃void insert(size_t pos, char ch);

void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if(_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : 2*_capacity;
		reserve(newcapacity);
	}
	size_t end = _size + 1;
	while(end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

🍃void insert(size_t pos, const char* str);

void 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;
	while(end >= pos + len)
	{
		_str[end] = _str[end - len];
		--end;
	}
	memcpy(_str + pos,str,len);
	// 由于strcpy会将后面的字符覆盖，所以这里要用memcpy
	_size += len;
}

13.🍁void erase(size_t pos = 0, size_t len = npos);

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

14.🍁find函数实现

🍃size_t find(char ch, size_t pos);

size_t string::find(char ch, size_t pos)
{
	assert(_size > pos);
	int index = pos;
	// npos在前面有定义
	while (index < _size)
	{
		if (_str[index] == ch)
			return index;
		++index;
	}
	return npos;
}

🍃size_t find(const char* str, size_t pos);

size_t string::find(const char* str, size_t pos)
{
	char* p = strstr(_str + pos, str);
	return p - _str;
}

15.🍁swap函数的实现

void string::swap(string& s)
{
	std::swap(_str,s._str);
	std::swap(_size,s._size);
	std::swap(_capacity,s._capacity);
}

16.🍁substr的实现

string string::substr(size_t pos, size_t len)
{
	if(len >= _size - pos)
	{
		string tmp(_str + pos);
		return tmp;
	}
	else
	{
		string tmp;
		tmp.reserve(len);
		for(int i = 0;i < len;++i)
		{
			tmp._str[i] = _str[pos + i];
		}
		// 这么些也可以
		// memcpy(tmp._str,_str + pos,len);
		tmp._size = len;
		return tmp;
	}
}

17.🍁运算符重载

bool operator<(const string& s) const;
bool operator>(const string& s) const;
bool operator<=(const string& s) const;
bool operator>=(const string& s) const;
bool operator==(const string& s) const;
bool operator!=(const string& s) const;

bool string::operator<(const string& s) const
{
	return strcmp(_str, s._str) < 0;
}

bool string::operator>(const string& s) const
{
	return !(_str < s._str);
}

bool string::operator<=(const string& s) const
{
	return _str < s._str || _str == s._str;
}

bool string::operator>=(const string& s) const
{
	return !(_str < s._str) || _str == s._str;
}

bool string::operator==(const string& s) const
{
	return strcmp(_str, s._str) == 0;
}

bool string::operator!=(const string& s) const
{
	return !(_str == s._str);
}

18.🍁>>重载函数和<<重载函数

🍃>>重载函数

由于流提取需要将整个值改变，所以需要清空原本的值，所以引用函数clear()。
由于流提取会自动忽略空格和换行，所以我们用get()函数来解决流提取问题

void string::clear()
{
	_str[0] = '\0';
	_size = 0;
}
istream& My_string::operator>> (istream& is, string& str)
{
	str.clear();
	char buff[128];
	char ch = is.get();
	int i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i] = ch;// 临时变量，能够快速生成
		++i;
		if (i == 127)// 当buff已经满了，进行+=操作
		{
			buff[i] = '\0';
			str += buff;
			i = 0;// 记得i要置为0
		}
		ch = is.get();// 提取下一个字符
	}
	if (i > 0)// 当还有字符没有进行插入时，继续进行+=操作
	{
		buff[i] = '\0';
		str += buff;
	}
	return is;
}

🍃<<重载函数

ostream& My_string::operator<<(ostream& os,const string& str)
{
	for (size_t i = 0; i < str.size(); i++)
	{
		os << str[i];
	}
	return os;
}

你学会了吗？
好啦，本章对于《C++：string的的模拟实现》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！

如你喜欢，点点赞就是对我的支持，感谢感谢！！！