【C++】string的模拟实现

一.string的模拟实现

string本质上是是一种char类型的顺序表，结构上和顺序表相似。

namespace Mystring
{
	class string
	{
	public:
	
	private:
	char* _str;//首元素的地址，指向字符串存放的空间的指针
	size_t _size;//字符串的的个数
	size_t _capacity;//可以使用的容量，其是用来表示_str的空间大小, _capacity 不包括字符串中 '\0' 所占的空间。
};

用命名空间进行封装，防止与库里面的冲突。

1.1构造函数和析构函数，以及一些简单函数

class string
{
public:
	string()//无参的析构函数
		:_str(nullptr)
		,_size(0)
		,_capacity(0)
	{}
	string(const char* str=" ")//带参的析构函数
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	const char* c_str()//写一个简单的打印函数，后面会补充流提取。
	{
		return _str;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
	static const size_t npos;
};

npos通常用于表示“未找到”或“不存在的位置”这样的特殊值。比如在 string 类的 find 函数中，当没有找到要查找的子串时，就会返回 npos 。

当我们运行程序时，程序崩了，这是因为_str无参构造时，初始化的时nullptr，转为字符串打印时会直接去解引用，然后按照字符串去打印，遇到\0才会终止，这里对空指针进行解引用，导致程序崩溃
我们进行改进一下

class string
{
public:
	/*string()
		:_str(new char[1]{'\0'})
		,_size(0)
		,_capacity(0)
	{}*/
	string(const char* str=“”)
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	const char* c_str() const 
	{
		return _str;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

这样写就没有问题了。

size_t size()const //返回字符串长度
{
   return _size;
}
char& operator[](size_t pos)//获取字符串字符,返回对字符串中位置pos处的字符的引用。
{
	assert(pos < _size);
	return _str[pos];
}

这些都是频繁调用或者是比较简单的函数，所以我们定义在类里。默认是内联函数。

1.2迭代器

实现基本的迭代器（正向迭代器和const正向迭代器）功能以支持 范围for，迭代器遍历。迭代器模拟的是指针的行为，迭代器并不是指针。

class string
{
public:
	typedef char* iterator;
	iterator begin()
	{
		return _str;
	}
	iterator end()
	{
		return _str + _size;
	}
			
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};

迭代器遍历，范围for遍历

1.3增删查改

这里开始声明与定义分离了。

这些都声明在.h文件中
.h
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, size_t len = npos);

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;
	}
}
//该函数可以更改容量。当n>容量时，
//则函数会使容器的容量增加到n个字符（或更多）。
//当n<时，增加多少是不确定的。

void string::pop_back(char ch)//该函数用于在字符串的末尾添加一个字符。使其长度+1。
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';//记得加\0
}

string& operator+=(char ch)//和push_back作用一样
{
	push_back(ch);
	return *this;
}
void append(const char* str);//在原来的字符串后面追加字符串
{
	size_t len = strlen(str);//计算str的长度
	if (_size + len > _capacity)
	{
		reserve(_size + len > _capacity ? _size + len : _capacity * 2);
	}
	strcpy(_str + _size, str);
	_size += len;
}
string& string::operator+=(const char* str)//在原来的字符串后面追加字符串
{
	append(str);
	return *this;
}

测试一下：

//在pos后面加一个字符
void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	//挪动数据
	size_t end = _size+1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

在pos后面加一个字符串
void string::insert(size_t pos, const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len > _capacity ? _size + len : _capacity * 2);
	}
	size_t end = _size + len;
	while (end > pos +len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}
	for (size_t i = 0; i < len; i++)
	{
		_str[pos + i] = str[i];
	}
	_size += len;
}

void string::erase(size_t pos, size_t len)//在pos位置删除len个字符
{
	if (len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (size_t i = pos+len; i <= _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size-=len;
	}
}

二.运算符重载

bool operator<(const string& s1, const string& s2)；
bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2)

这里可以用运算符的复用会比较简单，只需要实现两个，其他的就都可以实现。

bool operator<(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || (s1 == s2);
}
bool operator>(const string& s1, const string& s2)
{
	return !(s1 < s2);
}
bool operator>=(const string& s1, const string& s2)
{
	return !(s1 < s2) || (s1 == s2);
}
bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}
bool operator==(const string& s1, const string& s2)
{
	return  strcmp(s1.c_str(), s2.c_str()) == 0;
}

三.流插入和流提取

ostream& operator<<(ostream& out, string& s);
istream& operator>>(istream& in, string& s);

ostream& operator<<(ostream& out, string& s)
{
	for (auto ch : s)
	{
		out << ch;
	}
	return out;
}
istream& operator>>(istream& in, string& s)
{
	char ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}