STL —— string（终）

目录

1. swap() 函数的模拟实现

2. find() 函数的模拟实现

3. substr() 函数的模拟实现 

4. operator==()的重载模拟实现

5. << 和 >> 重载的模拟实现

6. getline() 的重载

7. 拷贝构造的现代写法

8. 赋值重载的现代写法

---

本片文章还是主要讲解 string 类中剩余几个函数的模拟实现：

1. swap() 函数的模拟实现

在C++库中就有swap()函数的实现，但是为什么要在string类中也要实现一个swap()函数呢？

我们可以先看一下库中的实现逻辑：

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

这里可以看到如果对内置类型，它会调用一次 拷贝构造、两次赋值重载、一次析构，而且都是深拷贝，这样的效率就会大大增加，虽然可以实现swap()的功能，但是一般不推荐使用，所以会在库中自己实现。

因此我们可以自己实现一个 swap() 函数，只要对内置类型进行交换即可：

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

 除此之外，为了防止调用算法库的swap()，我们可以写一个全局的swap():

void swap(string& x, string& y)
{
	x.swap(y);
}

---

2. find() 函数的模拟实现

查找字符的模拟实现：

size_t find(char ch, size_t pos = 0) const
{
	for (size_t i = pos; i < _size; ++i)
	{
		if (_str[i] == ch)
		{
			return i;
		}
		else
		{
			return npos;
		}
	}
}

查找字符串的模拟实现，可以用strstr()函数来完成，查找成功strstr会返回查询到的位置的指针， 查找失败则会返回空，因此要两个指针相减得到下标：

size_t find(const char* ch, size_t pos = 0) const
{
	// 字符串匹配
	const char* p = strstr(_str, ch);
	if (p)
	{
		return p - _str;
	}
	else
	{
		return npos;
	}

}

---

3. substr() 函数的模拟实现 

取子串的操作从pos位置开始，取len个，代码如下：

string substr(size_t pos = 0, size_t len = npos)
{
	string sub;
	if (len >= _size - pos)
	{
		for (size_t i = pos; i < _size; ++i)
		{
			sub += _str[i];
		}
	}
	else
	{
		for (size_t i = pos; i < pos + len; ++i)
		{
			sub += _str[i];
		}
	}
	return sub;
}

---

4. operator==()的重载模拟实现

这里就只实现==的重载，其他的重载只需要复用即可。

在库中重载是在全局中实现的，主要是为了实现 const char* 和 string 类型的比较，这里模拟实现就不在全局中实现了：

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

---

5. << 和 >> 重载的模拟实现

<< 的重载比较简单，注意重载成全局的就可以了：

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

cin 读不到' '或者'\n'，要用get()获取

  istream& operator>>(istream& in, string& s)
	{
		s.clear();

		char ch;
		//in >> ch;
		ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			// [0,126]
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}

			ch = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

---

6. getline() 的重载

和>>类似：

  istream& getline(istream& in, string& s)
    {
		s.clear();

		char ch;
		//in >> ch;
		ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != '\n')
		{
			buff[i++] = ch;
			// [0,126]
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}

			ch = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

---

7. 拷贝构造的现代写法

这个是拷贝构造的正常的写法：

• 先动态开辟一块内存，并把str._str中的数据拷贝到其中；
• 让_str指向ch指向的空间
• _size 和 _capacity 分别赋值

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

现代写法：

• 新建一个tmp对象用str._str初始化；
• 然后再和this进行交换就可以了。

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

---

8. 赋值重载的现代写法

这个是赋值重载的正常的写法：

• 新构建一块空间并把str中的值拷贝到其中；
• 释放掉this->_str指向的空间；
• 让this->str 指向这块空间；
• 给this->_size 和 this->_capacity 赋值

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

	return *this;
}

现代写法：

• 新建一个tmp对象用str拷贝构造；
• this和tmp进行交换；
• 因为局部变量出作用域会自动调用析构函数，所以这里不需要自己重新写一份delete[] tmp._str 释放掉this原来指向的空间，如果写了delete，记得把tmp._str 制空；

string& operator=(const string& str)
{
	string tmp(str);
	swap(tmp);
	return *this;
}

还有更简单的写法：

因为这里是传值传参，会自动调用拷贝构造，就不需要我们自己手动写一个tmp的拷贝构造了。

string& operator=(string str)
{
	swap(str);
	return *this;
}