9.string的修改操作

9.1尾插

push_back()

在字符串后面插入一个字符

append()

?在字符串结尾插入一个string对象、string对象的一部分、一个字符串、一个字符串的前n个字符、n个c字符(没指定字符就会默认插入\0)或者一段迭代器区间。

注意：在插入一个string对象的一部分时，如果没有指定长度，会默认将string对象的pos位置开始到结束都插入到原字符串后面；如果指定的长度大于剩余部分的话，也会将剩余的所有字符全都尾插到后面

?operator+=

尾插一个string对象、一个字符串、一个字符?

	string s3("hello world");

	s3 += 'x';
	s3 += "abcdefg";
	s3 += s1;

因为+=非常形象，所以使用的最多?

?9.2insert()

insert就是在指定位置上插入数据。

insert设计了非常多的接口，?但是因为insert涉及到数据的挪动以及扩容等，效率较低，所以使用的也不是很多

9.3assign()?

用指定内容替代原内容

assign也设计了多个接口，但assign依旧不常用，需要用时查文档即可

9.4erase()

1、删除指定位置开始的n个字符，如果不指定长度或者长度大于剩余字符，都会将剩余字符全部删除

string s("hello world");
cout << s << endl;

//s.erase(6);
s.erase(6, 100);
cout << s << endl;//hello

2、删除一个指定迭代器位置上的字符

可以借此来实现头删

//s.erase(0,1);
s.erase(s.begin());

3、删除一个迭代器区间

因为erase删除数据也要挪动数据，而且对于字符串来说经常都是只加不减，所以这个接口也不常用?

9.5replace()

replace就是用指定的内容提供替换指定位置上的元素

replace可以和find等查找接口结合使用，达到替换指定元素的目的

下面代码的功能就是将字符串中的所有空格都替换成%%。?

string s1("hello wrold sunday xxx");

size_t pos = s1.find(' ');
while (pos != string::npos)
{
	s1.replace(pos, 1, "%%");
	pos = s1.find(' ', pos + 2);//指定从那个位置开始查找
}

因为这里是将一个字符替换成了两个字符，不仅需要扩容还需要挪动数据。但是如果遇到空格比较多且连续的话需要频繁扩容，效率低?

可以采取另一种方式来实现替换：创建一个空string，然后遍历原字符串，遇到非空格就加等该字符，遇到空格就加等%%。?而且我们还可以提前开好空间，避免多次扩容

string tmp;
tmp.reserve(s1.size());
for (auto e : s1)
{
	if (e == ' ')
	{
		tmp += "%%";
	}
	else
	{
		tmp += e;
	}
}

9.6swap()、pop_back()

swa()就是交换两个string对象

pop_back()是C++11提供的一个尾删接口

10.string的其他操作

string s("hello.zip.cpp");
size_t pos = s.rfind('.');
string ans = s.substr(pos);

10.1查找

find

从指定位置开始查找一个string对象/字符串/字符出现的第一个位置，如果找到了就会返回该位置的下标，如果没找到就会返回npos。

?rfind

和find的功能类似，只不过是倒着查找第一个出现的位置。

当遇到需要查找文件的后缀时，且该文件不只一个‘.’。如果采用find查找的话就会出错，这时候从后向前查找更好。

string s("hello.zip.cpp");
size_t pos = s.rfind('.');
string ans = s.substr(pos);

?

find_first_of

?从字符串中找出第一个与指定字符串中的任何一个元素

	std::string str("Please, replace the vowels in this sentence by asterisks.");
	std::cout << str << '\n';

	std::size_t found = str.find_first_of("abcdef");
	while (found != std::string::npos)
	{
		str[found] = '*';
		found = str.find_first_of("abcdef", found + 1);
	}

	std::cout << str << '\n';

就如这段代码，我们可以将指定字符串中的abcdef都替换成*。?

find_last_of?

与find_first_of类似，其实就是倒着开始找。

这个接口可以用来实现路径与文件名的分离。而在windows操作系统和Linux操作系统中，Windows的文件分隔符是\，而Linux是/。为了同时区分这两个系统下的文件，我们就可以采用find_last_of来实现。?

void SplitFilename(const std::string& str)
{
	std::cout << "Splitting: " << str << '\n';
	std::size_t found = str.find_last_of("/\\");
	std::cout << " path: " << str.substr(0, found) << '\n';
	std::cout << " file: " << str.substr(found + 1) << '\n';
}

int main ()
{
  std::string str1 ("/usr/bin/man");
  std::string str2 ("c:\\windows\\winhelp.exe");

  SplitFilename (str1);
  SplitFilename (str2);

  return 0;
}

?因为在程序中\是转义字符，所以不会单独存在，为了表示\，所以需要用\\来表示。

find_first_not_of和find_last_not_of

它们的功能就是上面两者的反面，返回第一个不是指定字符里的任意一个的字符

下面代码的意思就是将abcdef之外的字符全部替换成*。?

std::string str("Please, replace the vowels in this sentence by asterisks.");
	std::cout << str << '\n';

	std::size_t found = str.find_first_not_of("abcdef");
	while (found != std::string::npos)
	{
		str[found] = '*';
		found = str.find_first_not_of("abcdef", found + 1);
	}

	std::cout << str << '\n';

10.2c_str()

?返回堆上存储字符串的空间的地址

这个接口的实现，主要是为了兼容C语言。使C++程序可以调用C语言的接口。

10.3copy()

?从string对象拷贝内容到指定字符串中

10.4substr()

生成一个字串?默认会从头开始获取，当不指定长度或者长度大于剩余字符都会获取到字符串结尾。

11.string的非成员函数?

11.1string重载了比较运算符，其比较逻辑与strcmp相同。

11.2operator+?

重载+是为了可以实现多种相加，不只局限于第一个参数是string对象。但接口设计的过于冗余且+的使用场景也不多。

11.3getline?

getline是string对象专用的一种流提取方式。

因为以往使用cin的话，会以空格或者换行为分隔符，但是如果一个字符串中含有空格，用cin输入的话，就会丢失空格之后的内容。

而getline是以换行符为分隔符，遇到空格不会停止读取，就不会丢失内容。

三.string的模拟实现?

在VS2022环境下实现string时，为了简单实现，就不再设计buffer字符数组用来存储长度小于15的字符串，且只实现些重要接口

模拟实现string的结构

为了避免与库里面的string冲突，所以将模拟实现的string定义到命名空间中。我们这里实现声明与定义到两个文件中：string.h string.cpp。

namespace xsc
{
	class string
	{
	private:
		char* _str;
		size_t _size;
		size_t _capacity;

		static const size_t npos;
	};
}

npos是一个静态成员，属于类，所以要在类外定义，放在.cpp文件中

namespace xsc
{
	static const size_t npos = -1;
}

不同文件的同一命名空间会合并。

1.构造函数?

首先实现无参构造和有参构造

在实现无参构造时，不能直接给_str赋空指针，也要开一个空间给\0，否则当打印由无参构造创建的对象时会发生对空指针的解引用

实现有参构造时，要注意多来一个空间给\0，因为size和capacity都是不包含\0的。?

string()
{
	_str = new char('\0');
	_size = 0;
	_capacity = 0;
}

string(const char* s)
{
	size_t len = strlen(s);
	_str = new char[len + 1];
	_size = len;
	_capacity = len;

	strcpy(_str, s);
}

我们也可以将两者合并，写一个带缺省值的有参构造：

string(const char* s = "")
{
	size_t len = strlen(s);
	_str = new char[len + 1];
	_size = len;
	_capacity = len;

	strcpy(_str, s);
}

我们给了一个空的常量字符串，而常量字符串结尾会自带一个\0,所以上面的写法就涵盖了之前的两种写法。

2.析构函数

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

3.c_str()/size()/capacity

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

size_t size() const
{
	return _size;
}

size_t capacity() const
{
	return _capacity;
}

4.迭代器

迭代器iterator其实是一种封装的体现。每一个容器都有iterator，但是每一个容器的底层的实现又是不一样的。而且iterator的实现也是不固定的，有可能时原生指针，也有可能是其他的机制来实现的。

所以每一个容器中的iterator其实是typedef出来的，实现一个统一的接口，让每一个容器的遍历方式都变得相同。

string的模拟实现过程中，可以用原生指针来实现迭代器，因为可以发现，在string中，迭代器其实是在模拟指针的行为。

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

迭代器实现后，范围for也就可以使用了。这也就从侧面反映出范围for的底层是迭代器。?

5.operator[]?

对于string的访问来说，没必要实现其他的接口，只需要实现该接口即可。

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

	return _str[pos];
}

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

	return _str[pos];
}

6.clear()

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

7.尾插

push_back及reserve

在每一次插入前都要先判断是否还有容量，如果容量满了就需要扩容?

扩容的操作交给reserve来实现，每次开空间时都要多开一个空间给\0。因为在VS环境下，n

void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		_capacity = n;
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
	}
}

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

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

append

实现append时，不能直接2倍扩容，如果s很长，扩大2倍可能还是不够，所以就要判断目前的长度加上s的长度与2*capacity谁大，来判断扩多少。?

void string::append(const char* s)
{
	size_t len = strlen(s);

	if (len + _size > _capacity)
	{
		reserve(len + _size > 2 * _capacity ? len + _size : 2 * _capacity);
	}
	_size += len;
	strcpy(_str + _size, s);
}

operator+=

实现+=时，可以直接复用前面的尾插操作。?

string& string::operator+=(char ch)
{
	push_back(ch);

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

	return *this;
}

?8.insert

在指定位置插入一个字符

void string::insert(size_t pos, char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	size_t end = _size + 1;
	while (end >= pos + 1)
	{
		_str[end] = _str[end - 1];
		--end;
	}

	_str[pos] = ch;
	++_size;
}

在指定位置插入一个字符串

void string::insert(size_t pos, const char* s)
{
	size_t len = strlen(s);

	if (len + _size > _capacity)
	{
		reserve(len + _size > 2 * _capacity ? len + _size : 2 * _capacity);
	}

	size_t end = _size + len;
	while (end >= pos + len)
	{
		_str[end] = _str[end - len];
		--end;
	}

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

	_size += len;
}

9.erase

void string::erase(size_t pos, size_t len)
{
	assert(pos < _size);

	if (len > _size - pos)
	{
		_str[pos] = '\0';
	}
	else
	{
		size_t i = pos + len;
		for (; i <= _size; ++i)
		{
			_str[i - len] = _str[i];
		}
	}
	
	_size -= len;
}

10.find/substr

实现substr时，这里返回了一个临时变量，出了作用域就销毁了，实际上会返回由这里临时变量拷贝出来的中间变量，但是这里默认实现的是浅拷贝。而且string类里面涉及到了资源的申请，实现浅拷贝的话，就会导致对同一块空间多次释放。

所以这里还需要实现拷贝构造来实现深拷贝。?

size_t string::find(char ch, size_t pos)
{
	assert(pos < _size);

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

size_t string::find(const char* s, size_t pos)
{
	assert(pos < _size);

	char* tmp = strstr(_str + pos, s);
	if (tmp == nullptr)
	{
		return -1;
	}
	return tmp - _str;
}

string string::substr(size_t pos, size_t len)
{
	string ans;

	if (len > _size - pos)
	{
		len = _size - pos;
	}

	ans.reserve(len);

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

	return ans;
}

拷贝构造

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

赋值运算符重载

//s1 = s
string& operator=(const string& s)
{
	//避免自己对自己赋值
	if (this != &s)
	{
		delete[]_str;

		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}

11.Cmpare

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

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

12.流插入和流提取

在实现流提取时，为了避免多次扩容，可以开一个数组先用来存储数据，等数组满了在插入string中，减少扩容次数。

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

	return out;
}

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

	const int N = 256;
	char buff[N];
	int i = 0;

	char ch;
	//in >> ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == N - 1)
		{
			buff[i] = '\0';
			s += buff;

			i = 0;
		}

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

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

	return in;
}

四.现代写法?

拷贝构造现代写法

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

//s1(s)
string(const string& s)
{
	string tmp(s.c_str());
	swap(tmp);
}

现代写法与传统写法的区别就在于：传统写法是自己开空间自己挪动数据；现代写法则是将这些过程都交给tmp去干。

我们用我们用s的内容去构造一个string对象，此时tmp就有和s一样大的空间和内容。此时我们再交换tmp和this的内容、size和capacity即可。

需要注意的是，tmp交换之后就得到this的值，而this还没有创建是随机值，tmp出了作用域就会销毁，此时就会导致对野指针进行销毁。为了避免这样，我们可以在声明私有成员变量时，给出缺省值

---

赋值运算符重载的现代写法?

//s1 = s
string& operator=(const string& s)
{
	string tmp(s.c_str());
	swap(tmp);

	return *this;
}

之前依旧时自己开空间拷贝数据，现代写法用一个tmp来帮忙实现之前需要自己干的事情。对于赋值运算符重载来说，s1要先释放自己之前的空间，再开一个和s一样大的空间和内容。

先用tmp创建一个和s一样的string对象，然后交换s1和tmp，此时s1就完成了目的，然后在该函数结束之后，tmp就会销毁，而它现在指向的又是s1之前的空间，刚好销毁了，不会造成内存泄露的问题。?

//s1 = s
string& operator=(string s)
{
	swap(s);

	return *this;
}

?现代写法可以再进行简化：此时传参不再传引用，而只是s的拷贝，此时直接交换s1和s，s1就得到了目标内容，而s得到了s1需要释放的空间，而s又是临时变量，出了作用域会销毁，会带走s1之前的空间，依旧不会造成内存泄露。

---

swap

在实现现代写法时，涉及到了交换，这个交换是我们自己实现的，为什么不直接调用库里面的swap呢？

库里面swap实现成了模板，当我们直接调用时，在该函数中会发生三个深拷贝。而我们用其交换自定义类型时就不会产生太多消耗。

但其实并不需要太多担心，当我们调用库里的swap时，其会调用swap(string& str).

五.引用计数和写时拷贝

浅拷贝的问题在于：

1、同一块空间析构两次或多次

2、修改一个另一个也会跟着改变

引用计数是指，一开始并不采用深拷贝，而是浅拷贝。只不过此时有一个count变量用来记录有多少个对象指向该空间

?当我们要析构s2时，不会直接析构该空间，而是让count--，直到count等于0时，才会真正释放该空间。

而当我们要对s2进行修改时，为了不改变s1，此时才会进行深拷贝，让s2指向另一块空间，这时候修改变不会影响s1。

引用计数和写时拷贝很好的解决了浅拷贝出现的问题。但是这在现在已经慢慢退出使用了。

VS2022环境下：

可以看到它们指向的地址并不相同，所以并没有采用引用计数和写时拷贝这种方式

g++环境下： 在g++环境下，我们可以看到，s1和s2指向的是同一块堆空间。

当我们对s2进行修改时，此时就会发生深拷贝，s2不在指向该地址：?

六.编码

编码其实是在计算机中，值和符号的一种映射关系。在计算机中只能存储010101这样的整数，然而我们需要经常表示字母符号中文等等。

Ascii码值就是一种编码，它将英文中常用的字母符号数字等等用整数来表示。

我们看到的abc在内存中其实就是97、98、99等数字，只不过在内存中是以十六进制存储的。?

而我们现在常用的就是Unicode(统一码、万国码)。它为世界上所有的文字和符号提供一个统一且唯一的编码的标准。

而其中包括了三种编码方式：UTF-8,UTF-16,UTF-32。

最常用的是UTF-8，它是一种变长编码。?它即可以表示字母，也可以表示中文等其他符号。中文通常用2个或者3个字节来表示。不同的符号用不同的字节数来表示。

UTF-16则都用两个字节来表示

UTF-32?则都用四个字节来表示