目录

一、string类的成员变量

二、构造函数

2.1 无参版本

2.2 有参版本

2.3 缺省值版本

三、析构函数

四、拷贝构造函数

五、c_str函数

六、operator=重载

七、size函数

八、迭代器iterator

8.1 正常版本

8.2 const版本

九、operator[]

9.1 正常版本

9.2 const版本

十、reserve函数

十一、push_back函数

十二、append函数 -- 字符串版本

十三、operator+=

13.1 尾插字符

13.2 尾插字符串

十四、insert函数

十五、erase函数

十六、find函数

十七、swap函数

十八、 substr函数

十九、clear函数

二十、operator<< 和 operator >>

---

一、string类的成员变量

private:
	char* _str;
	size_t _size;
	size_t _capacity;

	const static size_t npos = -1;

二、构造函数

2.1 无参版本

// 无参
string()
{
	_str = new char[1];
	_str[0] = '\0';
	_size = 0;
	_capacity = 0;
}

2.2 有参版本

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

2.3 缺省值版本

事实上，string类的构造函数不可能有两个版本。所以可以使用缺省值来实现构造函数

// 缺省参数
string(const char* str = "")
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

唯一需要注意的是缺省参数该怎么给？

• 由于strlen()是遍历字符串直到遇到'\0'才结束，所以缺省值不能给nullptr，因为strlen会对指针进行解引用。
• 也不能给'\0'。因为'\0'是字符常量，而str是字符指针，它两类型不匹配，所以也会报错。

三、析构函数

当_str指向的空间为空时，delete函数内部会有判断机制。如果是空指针，delete函数不会运行。

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

四、拷贝构造函数

// 拷贝构造函数
string(const string& str)
{
	// 传统版本
	_str = new char[str._capacity + 1];
	strcpy(_str, str._str);

	_size = str._size;
	_capacity = str._capacity;
}

五、c_str函数

// c_str()函数
const char* c_str() const
{
	return _str;
}

六、operator=重载

// operator= 重载
string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;

		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}

	return *this;
}

七、size函数

// size()函数
size_t size() const
{
	return _size;
}

八、迭代器iterator

8.1 正常版本

typedef char* iterator;

// 非const版本的迭代器
iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

8.2 const版本

typedef const char* const_iterator;

// const版本的迭代器
const_iterator begin() const
{
	return _str;
}

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

九、operator[]

• operator[]运算符重载，由于string类对象并不是内置类型，所以想要获取字符串里的字符就得用[下标]的方式。
• operator[]不仅仅可以读也可以写，所以返回类型就不能是char，而是使用引用返回char&。

9.1 正常版本

// []运算符重载 -- 非const版本
char& operator[](size_t pos)
{
	assert(pos <= _size);

	return _str[pos];
}

 

9.2 const版本

// []运算符重载 -- const版本
const char& operator[](size_t pos) const
{
	assert(pos <= _size);

	return _str[pos];
}

十、reserve函数

由于_size和_capacity只包括有效字符而不包括'\0'。所以要默认多开一个空间来存放'\0'。

// reserve()函数 -- 新开一个大小为n+1的空间，然后把原数组的数据拷贝到新数组，再delete原数组，最后指针指向新数组
void reserve(size_t n)
{
	if (n > _capacity)
	{
		// 开辟的空间+1代表给'\0'也开了个空间
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

 

十一、push_back函数

• 对于追加单个字符来说，因为追加字符的数量是已知的，所以可以用reserve函数来控制字符串的容量。
• 在追加字符之前首先得先判定当前字符的数量是否等于字符串的容量。等于就扩容。不等于就正常插入即可。

// push_back()函数
void push_back(char ch)
{
	if (_size == _capacity)
	{
		size_t NewCapacity = _capacity == 0 ? 4 : 2 * _capacity;
		reserve(NewCapacity);
	}

	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';
}

十二、append函数 -- 字符串版本

字符串相较于字符比较难以控制追加的数量，所以得先求出追加字符串的长度，再判断追加字符串的长度 + 当前字符串的长度是否大于当前容器的容量。

大于就扩容，不大于就使用strcpy函数在已重新扩容的字符串中尾插待插入字符串。

// append()函数
void append(const char* s)
{
	size_t len = strlen(s);
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}

	strcpy(_str + _size, s);
	_size += len;
}

十三、operator+=

13.1 尾插字符

尾插字符就复用push_back函数

// operator+=重载 -- 字符
string& operator+= (char ch)
{
	push_back(ch);

	return *this;
}

13.2 尾插字符串

尾插字符串就复用append函数

// operator+=重载 -- 字符串
string& operator+= (const char* str)
{
	append(str);

	return *this;
}

 

十四、insert函数

// insert()函数 -- 插入字符串
string& insert(size_t pos, const char* str)
{
	assert(pos < _size);

	size_t len = strlen(str);
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}

	//size_t end = _size;
	int end = _size;
	while (end >= (int)pos) // 防止发生隐式类型转换
	{
		_str[end + len] = _str[end];
		--end;
	}

	strncpy(_str + pos, str, len);
	_size += len;

	return *this;
}

十五、erase函数

首先得先判断len是否等于缺省值npos或者 len + pos 是否大于等于字符串实际存储有效字符的数量。如果出现以上两种情况直接在字符串中下标为pos的值赋值为'\0'，再把pos赋给_size。

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

十六、find函数

用strstr函数找到要找字符串的地址，如果strstr函数返回值为空指针就返回npos。

反之则用返回的指针 - 当前字符串的指针。

// find()函数 -- 寻找字符
size_t find(char ch, size_t pos = 0) const
{
	for (size_t i = pos; i < _size; i++)
	{
		if (ch == _str[i])
		{
			return i;
		}
	}
	return npos;
}

// find()函数 -- 寻找字符串
size_t find(const char* s , size_t pos = 0) const
{
	const char* ptr = strstr(_str + pos, s);

	if (ptr == nullptr)
	{
		return npos;
	}
	else
	{
		return ptr - _str;
	}
}

十七、swap函数

// swap()函数
void swap(string& str)
{
	std::swap(_str, str._str);
	std::swap(_size, str._size);
	std::swap(_capacity, str._capacity);
}

十八、 substr函数

// substr()函数
string& substr(size_t pos = 0, size_t len = npos) 
{
	assert(pos <= _size);

	size_t end = pos + len;
	if (len == pos || pos + len >= _size)
	{
		end = _size;
	}

	string str;

	// 开一个新空间给子字符串，容量为end - pos
	str.reserve(end - pos);

	// 尾插到新字符串中
	for (size_t i = pos; i < len; i++)
	{
		str += _str[i];
	}
	return str;
}

十九、clear函数

// clear()函数
void clear()
{
	_size = 0;
	_str[0] = '\0';
}

二十、operator<< 和 operator >>

// 流插入重载 <<
ostream& operator<< (ostream& out, const string& s)
{
	for (char ch : s)
	{
		out << ch;
	}

	return out;
}

// 流提取重载 >>
istream& operator>> (istream& in, string& s)
{
	s.clear();

	// 提取缓冲区里的字符，遇到' '和'\n'就结束
	char ch = in.get();
	char buff[128];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[i] = '\0';
			s += buff;
			i = 0;
		}

		ch = in.get();
	}

	buff[i] = '\0';
	s += buff;

	return in;
}