【C++】string

string相关

这些构造函数其中常用的有：第一个无参构造，第二个拷贝构造，第四个字符串初始化，第六个使用n个字符c初始化。

其他几个构造可以了解，比如第三个：拷贝某个字符串，从pos位置开始拷贝，拷贝长度为len，这里len给了缺省值npos，npos=-1，但因为是无符号整型，所以它在这里是整型的最大值，也就是说不传第三个参数，默认传了整型最大值，也就是从pos位置拷贝到字符串结尾

由于string在类外面重载了<<和>>所以支持流插入和流提取

对于string对象的尾插，有几种方式：

1.push_back，只能尾插一个字符；

2.append，可以追加字符串，string对象等，使用广泛

实际场景中除了喜欢使用这两种方式，string还重载了+=运算符，使得尾插变得更加简洁。

string类对象的访问及遍历操作：

string重载了[ ]，其本质就是解引用，类似于数组，因此string也可类似的使用下标访问各位置的值

有两种传参方式，普通对象调用第一个，返回普通对象的引用，const对象调用第二个，返回const对象的引用，const对象不可修改，如果是普通对象那么可以利用[ ]进行修改，使用方式类似于数组

string的迭代器底层就是指针，它的使用方式如下：

访问string的方式除了上面的两种方式（[ ]下标访问；迭代器访问），还有一种方式：范围for，迭代器的使用可能比[ ]繁琐，但是范围for的底层就是迭代器，这是迭代器的一个好处，迭代器的另一个好处是迭代器是通用的，任何容器都支持迭代器，用法类似。

为什么一定要有迭代器，因为下标加[ ]未必所有容器都适用，比如链表，它的空间是不连续的，但是可以使用迭代器。

迭代器有普通迭代器和const迭代器，const迭代器只支持读，普通迭代器还支持写操作

迭代器还可以分成正向迭代器(begin(获取首个字符的迭代器)+end(获取最后一个字符的下一个位置的迭代器))和反向迭代器(rbegin+rend)

string类对象的容量操作：

size ： 返回字符串有效字符长度

length  ： 返回字符串有效字符长度

capacity  ： 返回空间总大小

empty  ： 检测字符串释放为空串，是返回 true ，否则返回 false

clear  ： 清空有效字符

reserve  ： 为字符串预留空间

resize  ： 将有效字符的个数该成 n 个，多出的空间用字符 c 填充

注意：

1. size() 与 length() 方法底层实现原理完全相同，引入 size() 的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size() 。

2. clear() 只是将 string 中有效字符清空，不改变底层空间大小。

3. resize(size_t n) 与 resize(size_t n, char c) 都是将字符串中有效字符个数改变到 n 个，不同的是当字符个数增多时：resize(n) 用 0 来填充多出的元素空间， resize(size_t n, char c) 用字符 c 来填充多出的元素空间。注意：resize 在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0) ：为 string 预留空间，不改变有效元素个数，当 reserve 的参数小于string的底层空间总大小时， reserver 不会改变容量大小。

5.capacity的值不同的编译器结果不一定相同，取决于不同编译器的扩容机制

string类对象的修改操作：

push_back ： 在字符串后尾插字符 c

append ： 在字符串后追加一个字符串（常用）

insert： 在字符串的某个位置插入字符（不常用）

operator+= ： 在字符串后追加字符串str

erease：  删除某一位置的字符（不常用）

c_str： 返回 C 格式字符串

find ： 从字符串 pos 位置开始往后找字符 c ，返回该字符在字符串中的位置

rfind ： 从字符串 pos 位置开始往前找字符 c ，返回该字符在字符串中的位置

substr ： 在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

string非成员函数：

operator+ ： 尽量少用，因为传值返回，导致深拷贝效率低

operator>> ： 输入运算符重载

operator<< ： 输出运算符重载

getline ： 获取一行字符串

relational operators ：  大小比较

string的其他操作：(具体看c++文档)

string模拟实现

构造&拷贝构造

析构函数

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

赋值运算符重载

迭代器

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类对象的容量操作相关函数

size_t size() const
		{
			return _size;
		}
void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				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 clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

string类对象的修改操作

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);
			}

			memcpy(_str + _size, str, len+1);
			_size += len;
		}
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)//npos=-1，end != npos防止的是pos为0时的情况，
			{                                //此时前一个判断条件只有在end小于0时才会结束，但是end是无符号整型
				_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;//调用拷贝构造，必须深拷贝
		}

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

运算符重载相关函数

        bool operator<(const string& s) const
		{
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);

			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);
		}

完整代码