string类的基本使用与模拟实现string类

一. 为什么要学习string类

在C语言中，字符串是使用字符数组表示的，这种方式比较容易出现错误，如数组越界、缓冲区溢出等。

C++的string类是一个标准库中的类，它是一个容器，可以存储字符串，同时提供了许多方便的方法来操作字符串，如查找、替换、拼接等。

使用string类，可以避免手动处理字符串时出现的错误，如内存泄漏、越界、缓冲区溢出等问题，同时也减少了代码量，提高了代码的可读性和可维护性。string类还支持重载运算符，使得对字符串的操作更加直观和方便。

因此，C++中引入string类是为了更加方便、安全地处理字符串，提高代码的可读性和可维护性。

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。

二. string类的基本使用

• 使用string类前需要包含头文件< string >

#include<string>

• 创建一个string类对象

string s1;

• 创建并初始化对象

string s2("hello world");
string s3 = "hello world";

• 使用[]或at()函数来访问字符串中的单个字符。区别是at()函数会进行边界检查，避免越界访问

string str = "hello world";
cout << str[0] << endl;
cout << str.at(1) << endl;

• 可以使用加号运算符+将两个字符串拼接起来，也可以使用append()函数将一个字符串添加到另一个字符串的末尾

string str1 = "hello";
string str2 = "world";
string str3 = str1 + str2;          // 将str1和str2拼接起来
string str4 = str1.append(str2);    // 将str2添加到str1的末尾
str+='a';                           // 向str末尾添加一个字符'a'

• 使用cin向string类对象中输入数据（遇到空格读取结束）

string str;
cin >> str;

• 使用getline函数向string类对象中输入数据（遇到换行符读取结束）

string str;
str.getline();

• 使用cout输出string类对象的内容

string str;
cout << str << endl;

三. string类的常用接口

1.访问及遍历函数

• operator[]：返回当前字符串中指定位置的字符
• at(size_t pos)：返回当前字符串中指定位置的字符，并进行边界检查

string str = "hello world";
cout << str[0] << endl;
cout << str.at(1) << endl;

• front()：返回当前字符串中的第一个字符
• back()：返回当前字符串中的最后一个字符

string str = "hello world";
cout << str.front() << endl;
cout << str.back() << endl;

• c_str()：返回一个指向当前字符串内容的C风格字符串；

string str = "hello world";
cout << str.c_str() << endl;

• 范围for:
  范围for循环是C++11新增的一种语法结构，用于遍历容器类中的元素。它可以遍历数组、容器类等可迭代的对象，使得程序员可以更加简洁地遍历容器中的元素，而不必关心迭代器的细节。
  范围for是基于迭代器实现的，也就是说有了迭代器我们就可以使用范围for了。

string str = "hello world";

for (auto c : str)
{
    
    
	cout << c << ' ';
}
cout << endl;

2.容量相关函数

• empty()：判断当前字符串是否为空

string str = "hello world";
cout << str.empty() << endl;

• size()：返回当前字符串的字符数，不包含'\0'

string str = "hello world";
cout << str.size() << endl;

• length()：返回当前字符串的字符数，不包含'\0'

string str = "hello world";
cout << str.length() << endl;

• capacity()：返回当前字符串容量，即可以存储的字符数

string str = "hello world";
cout << str.capacity() << endl;

• reserve()：为当前字符串分配指定的容量，即扩容

string str = "hello world";
str.reserve(100);

• resize()：扩容并初始化

string str = "hello world";
str.resize(100, 'a');

3.操作相关函数

• operator+：将两个字符串拼接起来
• append()：将一个字符串添加到另一个字符串的末尾

string str1 = "hello";
string str2 = "world";
string str3 = str1 + str2;          // 将str1和str2拼接起来
string str4 = str1.append(str2);    // 将str2添加到str1的末尾

• replace()：用一个字符串替换另一个字符串中的指定部分

//在下标为0处，替换1个字符'a'，长度为1
string str = "hello world";
cout << str.replace(0, 1, 1, 'a');

• insert()：在指定位置插入一个字符串

string str = "hello world";
cout << str.insert(0, "aaaa") << endl;  //在位置0处插入字符串
cout << str.insert(0, 5, 'a') << endl;  //在位置0处插入5个字符'a

• erase()：删除指定位置的一个字符或一段字符

string str = "hello world";
cout << str.erase(0,5) << endl;  //删除从位置0开始的5个字符
cout << str.erase() << endl;  //清空字符串

• substr()：返回一个子串，包含从指定位置开始的指定数量的字符

string str = "hello world";
//返回字符串中从位置0处开始的长度为3的字串
string substr = str.substr(0, 3);  

• find()：在当前字符串中查找指定子串的位置
• rfind()：在当前字符串中从后往前查找指定子串的位置

string str = "hello world";
//从位置0处开始寻找字串"world"，若找到就返回字串的起始位置
cout << str.find("world",0) << endl;

• compare()：将当前字符串与另一个字符串进行比较

string str1 = "hello";
string str2 = "world";
str1.compare(str2);

关于string类中的函数接口我们就简单认识这些。库中string类的接口有一百多个，但是我们平时高平率使用的也就几个到十几个而已。在以后的工作当中，我们应该注重官方文档的使用，多查询文档能使我们对接口的使用更加准确和规范。

四. string类中的迭代器

1.迭代器是什么

迭代器是一种通用的概念，它提供了一种方式来遍历容器中的元素，不必关心容器的具体类型和实现方式。在C++中，迭代器被广泛地应用于STL（标准模板库）中，包括vector、list、map等容器类，使得程序员可以方便地访问和操作容器中的元素。

迭代器的实现原理是基于指针，它本质上是一个类似于指针的对象，它指向容器中的元素，并提供了一组操作方法，使得程序员可以通过迭代器来遍历容器中的元素。迭代器可以像指针一样进行自增、自减操作，以及支持解引用操作来获取指向的元素值。

在目前阶段，我们不对迭代器做过多的讲解，我们可以粗浅的把它看作指针一样的东西来使用。

2.迭代器的使用

在C++中，字符串类string也支持迭代器的使用，可以使用迭代器来访问字符串中的每一个元素。

string类的迭代器提供了begin()和end()方法，begin()返回一个指向字符串第一个元素的迭代器，end()返回一个指向字符串最后一个元素的下一个位置的迭代器。这样，我们就可以使用迭代器来遍历整个字符串。

string str = "hello world";

// 使用迭代器遍历字符串
for (string::iterator it = str.begin(); it != str.end(); ++it) {
    
    
	cout << *it << " ";
}

五. 模拟实现string类

1.定义string类

为了区别于标准库中的string类，我们使用自己的命名空间，在自己命名空间中模拟实现string类。

string类包含这三个基本成员：

char* _str 字符数组；
size_t _size 大小；
size_t _capacity 容量；

此外还需声明一个static成员npos，npos为将来实现的某些成员函数的缺省值，值位-1:

namespace dianxia
{
    
    
	class string
	{
    
    
	public:
		//...
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		
		//类中进行声明
		static const size_t npos;
	}
	
	//类外定义npos
	const size_t string::npos = -1;
}

2.构造函数

string类提供两种构造方法：

• 直接构造

string str;

• 传字符串构造

string str("hello world");

• 对于传字符串构造的情况，我们可以实现用const char* str 来接收它
• 对于直接构造的情况，我们可以用缺省值来解决

//构造函数
string(const char* str = "") //使用缺省值
{
    
    
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];  //+1为'\0'预留空间
	//strcpy(_str, str);
	memcpy(_str, str, _size+1);
}

3.拷贝构造函数

我们还会遇到用string类对象进行构造的情况：

string s1;
string s2(s1);

拷贝构造虽然不写，编译器会自动实现，但是自动实现的拷贝构造为浅拷贝，对于string类中，成员变量会申请资源的情况，浅拷贝是行不通的，所以需要我们自己实现:

//拷贝构造
string(const string& s)
{
    
    
	_str = new char[s._capacity + 1];
	//strcpy(_str, s._str);
	memcpy(_str, s._str, s._size + 1);
	_size = s._size;
	_capacity = s._capacity;
}

4.赋值重载

string s1;
string s2 = s1;

void swap(string& s)
{
    
    
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
//赋值运算符重载
string& operator=(string tmp)
		{
    
    
			swap(tmp);

			return *this;
		}

5.析构函数

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

6.[]操作符重载

注意应对const对象与非const对象须实现不同的重载函数。

	//用于const对象只读
	const char& operator[](size_t pos) const
	{
    
    
		assert(pos < _size);
		return _str[pos];
	}
	//用于普通对象可读可写
	char& operator[](size_t pos)
	{
    
    
		assert(pos < _size);
		return _str[pos];
	}

7.比较运算符重载

bool operator<(const string& s) const
{
    
    
	int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
	
	// "hello" "hello"   false
	// "helloxx" "hello" false
	// "hello" "helloxx" true
	return ret == 0 ? _size < s._size : ret < 0;
}

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

bool operator<=(const string& s) const
{
    
    
	return *this < s || *this == s;
}

bool operator>(const string& s) const
{
    
    
	return !(*this <= s);
}

bool operator>=(const string& s) const
{
    
    
	return !(*this < s);
}

bool operator!=(const string& s) const
{
    
    
	return !(*this == s);
}

8.c_str、size、capacity

• c_str：返回C底层的字符串
• size：返回_size
• capacity：返回_capacity

	const char* c_str()
	{
    
    
		return _str;
	}
	
	size_t size() const
	{
    
    
		return _size;
	}

	size_t capacity() const
	{
    
    
		return _capacity;
	}

9.resize与reserve

• resize：扩容并初始化
• reserve：只扩容

void reserve(size_t n)
{
    
    
	if (n > _capacity)
	{
    
    
		char* tmp = new char[n + 1];
		//strcpy(tmp, _str);
		memcpy(tmp, _str, _size+1);

		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

void resize(size_t n, char ch = '\0')
{
    
    
	if (n < _size)
	{
    
    
		_size = n;
		_str[_size] = '\0';
	}
	else
	{
    
    
		reserve(n);

		for (size_t i = _size; i < n; i++)
		{
    
    
			_str[i] = ch;
		}

		_size = n;
		_str[_size] = '\0';
	}
}

10.添加数据 - push_back、append、+=重载

• push_back：尾插一个字符
• append：尾插一个字符串
• +=：尾插一个字符或字符串

void push_back(char ch)
{
    
    
	if (_size == _capacity)
	{
    
    
		// 2倍扩容
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}

	_str[_size] = ch;

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

void append(const char* str)
{
    
    
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
    
    
		// 至少扩容到_size + len
		reserve(_size+len);
	}

	//strcpy(_str + _size, str);
	memcpy(_str + _size, str, len+1);

	_size += len;
}

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

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

11.insert

• insert：在pos位置插入一个字符或字符串

void insert(size_t pos, size_t n, char ch)
{
    
    
	assert(pos <= _size);

	if (_size +n > _capacity)
	{
    
    
		// 至少扩容到_size + len
		reserve(_size + n);
	}

	// 添加注释最好
	size_t end = _size;
	while (end >= pos && end != npos)
	{
    
    
		_str[end + n] = _str[end];
		--end;
	}

	for (size_t i = 0; i < n; i++)
	{
    
    
		_str[pos + i] = ch;
	}

	_size += n;
}

void insert(size_t pos, const char* str)
{
    
    
	assert(pos <= _size);

	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
    
    
		// 至少扩容到_size + len
		reserve(_size + len);
	}

	// 添加注释最好
	size_t end = _size;
	while (end >= pos && end != npos)
	{
    
    
		_str[end + len] = _str[end];
		--end;
	}

	for (size_t i = 0; i < len; i++)
	{
    
    
		_str[pos + i] = str[i];
	}

	_size += len;
}

12.erase

• erase：删除pos位置向后的n个字符

void erase(size_t pos, size_t len = npos)
		{
    
    
			assert(pos <= _size);

			if (len == npos || pos + len >= _size)
			{
    
    
				_str[pos] = '\0';
				_size = pos;

				_str[_size] = '\0';
			}
			else
			{
    
    
				size_t end = pos + len;
				while (end <= _size)
				{
    
    
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

13.find

• find：从pos位置开始向后查找指定字符或字符串，并返回起始位置的下标

size_t find(char ch, size_t pos = 0)
{
    
    
	assert(pos < _size);

	for (size_t i = pos; i < _size; i++)
	{
    
    
		if (_str[i] == ch)
		{
    
    
			return i;
		}
	}

	return npos;
}

size_t find(const char* str , size_t pos = 0)
{
    
    
	assert(pos < _size);

	const char* ptr = strstr(_str + pos, str);
	if (ptr)
	{
    
    
		return ptr - _str;
	}
	else
	{
    
    
		return npos;
	}
}

14.substr

• substr:从pos位置获取一个长度为n的子串

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

	size_t n = len;
	if (len == npos || pos + len > _size)
	{
    
    
		n = _size - pos;
	}

	string tmp;
	tmp.reserve(n);
	for (size_t i = pos; i < pos + n; i++)
	{
    
    
		tmp += _str[i];
	}

	return tmp;
}

15.clear

• clear:清理数据

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

16.迭代器

有了迭代器，我们就能对自己实现的类使用范围for了。

	//迭代器
	typedef char* iterator;
	typedef const char* const_iterator;

	iterator begin()
	{
    
    
		return _str;
	}

	iterator end()
	{
    
    
		return _str + _size;
	}

	const_iterator begin() const
	{
    
    
		return _str;
	}

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

17.>> 与 << 重载

注意这两个函数须定义在类外。

 	ostream& operator<<(ostream& out, const string& str)
	{
    
    
		for (auto ch : str)
		{
    
    
			out << ch;
		}
		
		return out;
	}

	istream& operator>>(istream& in, string& str)
	{
    
    
		str.clean();

		char ch = in.get();
		char buff[128]; //避免因频繁扩容导致效率过低
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
    
    
			buff[i++] = ch;
			if (i == 127)
			{
    
    
				buff[127] = '\0';
				str += buff;
				i = 0;
			}
			ch = in.get();
		}

		if (i != 0)
		{
    
    
			buff[i] = '\0';
			str += buff;
		}

		return in;
	}

18.完整源码

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

		iterator begin()
		{
    
    
			return _str;
		}

		iterator end()
		{
    
    
			return _str + _size;
		}

		const_iterator begin() const
		{
    
    
			return _str;
		}

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

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

		string(const string& s)
		{
    
    
			_str = new char[s._capacity + 1];
			//strcpy(_str, s._str);
			memcpy(_str, s._str, s._size + 1);
			_size = s._size;
			_capacity = s._capacity;
		}

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

			return *this;
		}

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

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

		size_t size() const
		{
    
    
			return _size;
		}

		char& operator[](size_t pos)
		{
    
    
			assert(pos < _size);

			return _str[pos];
		}

		const char& operator[](size_t pos) const 
		{
    
    
			assert(pos < _size);

			return _str[pos];
		}

		void reserve(size_t n)
		{
    
    
			if (n > _capacity)
			{
    
    
				cout << "reserve()->" << n << endl;

				char* tmp = new char[n + 1];
				//strcpy(tmp, _str);
				memcpy(tmp, _str, _size+1);

				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

		void resize(size_t n, char ch = '\0')
		{
    
    
			if (n < _size)
			{
    
    
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
    
    
				reserve(n);

				for (size_t i = _size; i < n; i++)
				{
    
    
					_str[i] = ch;
				}

				_size = n;
				_str[_size] = '\0';
			}
		}

		void push_back(char ch)
		{
    
    
			if (_size == _capacity)
			{
    
    
				// 2倍扩容
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;

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

		void append(const char* str)
		{
    
    
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
    
    
				// 至少扩容到_size + len
				reserve(_size+len);
			}

			//strcpy(_str + _size, str);
			memcpy(_str + _size, str, len+1);

			_size += len;
		}

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

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

		void insert(size_t pos, size_t n, char ch)
		{
    
    
			assert(pos <= _size);

			if (_size +n > _capacity)
			{
    
    
				// 至少扩容到_size + len
				reserve(_size + n);
			}

			size_t end = _size;
			while (end >= pos && end != npos)
			{
    
    
				_str[end + n] = _str[end];
				--end;
			}

			for (size_t i = 0; i < n; i++)
			{
    
    
				_str[pos + i] = ch;
			}

			_size += n;
		}

		void insert(size_t pos, const char* str)
		{
    
    
			assert(pos <= _size);

			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
    
    
				// 至少扩容到_size + len
				reserve(_size + len);
			}

			// 添加注释最好
			size_t end = _size;
			while (end >= pos && end != npos)
			{
    
    
				_str[end + len] = _str[end];
				--end;
			}

			for (size_t i = 0; i < len; i++)
			{
    
    
				_str[pos + i] = str[i];
			}

			_size += len;
		}

		void erase(size_t pos, size_t len = npos)
		{
    
    
			assert(pos <= _size);

			if (len == npos || pos + len >= _size)
			{
    
    
				_str[pos] = '\0';
				_size = pos;

				_str[_size] = '\0';
			}
			else
			{
    
    
				size_t end = pos + len;
				while (end <= _size)
				{
    
    
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

		size_t find(char ch, size_t pos = 0)
		{
    
    
			assert(pos < _size);

			for (size_t i = pos; i < _size; i++)
			{
    
    
				if (_str[i] == ch)
				{
    
    
					return i;
				}
			}

			return npos;
		}

		size_t find(const char* str , size_t pos = 0)
		{
    
    
			assert(pos < _size);

			const char* ptr = strstr(_str + pos, str);
			if (ptr)
			{
    
    
				return ptr - _str;
			}
			else
			{
    
    
				return npos;
			}
		}

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

			size_t n = len;
			if (len == npos || pos + len > _size)
			{
    
    
				n = _size - pos;
			}

			string tmp;
			tmp.reserve(n);
			for (size_t i = pos; i < pos + n; i++)
			{
    
    
				tmp += _str[i];
			}

			return tmp;
		}

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

		bool operator<(const string& s) const
		{
    
    
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			
			// "hello" "hello"   false
			// "helloxx" "hello" false
			// "hello" "helloxx" true
			return ret == 0 ? _size < s._size : ret < 0;
		}

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

		bool operator<=(const string& s) const
		{
    
    
			return *this < s || *this == s;
		}

		bool operator>(const string& s) const
		{
    
    
			return !(*this <= s);
		}

		bool operator>=(const string& s) const
		{
    
    
			return !(*this < s);
		}

		bool operator!=(const string& s) const
		{
    
    
			return !(*this == s);
		}

	private:
		size_t _size;
		size_t _capacity;
		char* _str;
	
	public:
		const static size_t npos;
	};

	const size_t string::npos = -1;

	ostream& operator<<(ostream& out, const string& s)
	{
    
    
		for (auto ch : s)
		{
    
    
			out << ch;
		}

		return out;
	}

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

		char ch = in.get();
		// 处理前缓冲区前面的空格或者换行
		while (ch == ' ' || ch == '\n')
		{
    
    
			ch = in.get();
		}

		char buff[128];
		int i = 0;

		while (ch != ' ' && ch != '\n')
		{
    
    
			buff[i++] = ch;
			if (i == 127)
			{
    
    
				buff[i] = '\0';
				s += buff;
				i = 0;
			}

			//in >> ch;
			ch = in.get();
		}

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

		return in;
	}
};

---

本文到此结束,码文不易,还请多多支持 ! ! !