C++(12)——string

	
 string& insert (size_t pos, const string& str);

 string& insert (size_t pos, const char* s);

 string& insert (size_t pos, const char* s, size_t n);

 string& insert (size_t pos, size_t n, char c);

 iterator insert (iterator p, char c);

1.1??string& insert (size_t pos, const string& str)：

对于本部分标题中的函数，其作用为在已有 $string$ 类型的对象的第 $pos$ 个位置插入另一个 $string$ 类型的对象，具体方法如下：

int main()
{
	string s1("hello world");
	string s2("xxx");

	s1.insert(5, s2);
	cout << "插入后" << endl;
	cout << s1 << endl;
	
	return 0;
}

运行结果如下：

**1.2??string& insert (size_t pos, const char* s)：**

对于本部分标题中的函数，其作用为在已有 $string$ 类型的对象的第 $pos$ 个位置插入一个常量字符串，具体使用方法如下：

string s1("hello world");

char a[] = { "aaaaaa" };
s1.insert(5, a);
cout << "插入后" << endl;
cout << s1 << endl;

运行结果如下：

**1.3??string& insert (size_t pos, const char* s, size_t n)：**

对于本部分标题中的函数，其作用为在已有 $string$ 类型的对象的第 $pos$ 个位置插入另一个另一个常量字符串的前 $n$ 个字符，具体使用方法如下：

string s1("hello world");
char a[] = { "aaaaaa" };
	
s1.insert(5, a, 1);
cout << "插入后" << endl;
cout << s1 << endl;

运行结果如下：

1.4??string& insert (size_t pos, size_t n, char c)：

对于本部分标题中的函数，其作用为在已有 $string$ 类型的对象的第 $pos$ 个位置插入 $n$ 个连续的字符。例如在一个 $string$ 类型的对象的第 $5$ 个位置插入两个连续的字符&:

string s1("hello world");

char a = '&';
	
s1.insert(5, 2,a);
cout << "插入后" << endl;
cout << s1 << endl;

运行结果如下：

此外，本函数经常用做在 $string$ 类型对象中进行头插，例如：

string s1("hello world");
	
char a = '&';	
s1.insert(0,1,a);
cout << "插入后" << endl;
cout << s1 << endl;

运行结果如下：

1.5??iterator insert (iterator p, char c)：

对于本部分标题中的函数，其作用为通过迭代器来向 $string$ 类型的对象中插入字符，例如：

	string::iterator it = s1.begin();
	s1.insert(it, 'x');
	cout << "插入后" << endl;
	cout << s1 << endl;

	s1.insert(s1.begin(), 'c');
	cout << "插入后" << endl;
	cout << s1 << endl;

	s1.insert(it + 3, 's');
	cout << "插入后" << endl;
	cout << s1 << endl;

运行结果如下：

2. erase:

	
string& erase (size_t pos = 0, size_t len = npos);

iterator erase (iterator p);

iterator erase (iterator first, iterator last);

2.1?string& erase (size_t pos = 0, size_t len = npos):
?

对于函数 $erase$ ，其功能是对已有的 $string$ 类型的对象中的内容进行删除。对于本标题中的函数，其中的两个参数均有缺省值，对于第一个参数，即：

size_t pos = 0

意义为：如果不认为给定参数，则默认从对象的开头进行删除。

对于第二个参数，即：

size_t len = npos

其意义为：删除对象中内容的长度。如果不人为给定参数，则默认删除到 $npos$ ，对于 $npos$ ，是一个常数，大小为 $4294967295$ ，在本部分可以理解为：如果没有给定参数，则直接删除对象中的所有内容。

对于不给参数调用 $erase$ ，即：

int main()
{
	string s1("hello world");
	s1.erase();
	cout << s1 << endl;

	return 0;
}

运行结果为：

假如指定从对象的第 $5$ 个字符，即下标为 $4$ 开始删除一直到最后，即：

int main()
{
	/*void Test1();
	*/
	string s1("hello world");
	s1.erase(4);
	cout << s1 << endl;

	return 0;
}

运行结果为：

?假设指定从对象的第 $5$ 个字符开始，删除到对象的第 $8$ 个字符，即删除内容的长度为 $4$ ：

2.2 iterator erase (iterator p)：

本部分标题给出的函数主要是让 $erase$ 与迭代器进行结合，函数的参数只有一个，本函数的意义为：删除迭代器位置的字符。例如：

	string s1("hello world");
	s1.erase(s1.begin());
	cout << s1 << endl;

运行结果如下：

如果想删除对象中的第三个字符，也就是下标为 $2$ 的位置的字符，即：


	string s1("hello world");
	s1.erase(s1.begin()+2);
	cout << s1 << endl;

?运行结果如下：

2.3?iterator erase (iterator first, iterator last)：

对于本部分标题中的函数的参数与上一个函数相同，但是本函数是删除 $[first,last)$ 这个区间的字符，例如：

string s1("hello world");

s1.erase(s1.begin()+2,s1.end()-2);
cout << s1 << endl;

运行结果如下：

3. find:

size_t find (const string& str, size_t pos = 0) const;
	
size_t find (const char* s, size_t pos = 0) const;
	
size_t find (const char* s, size_t pos, size_t n) const;

size_t find (char c, size_t pos = 0) const;

3.1?size_t find (const string& str, size_t pos = 0) const:

? ? ? ?对于本部分标题中的函数，其大致意义为：给定一个 $string$ 类型的对象 $str$ ，在已有的 $string$ 类型的对象中去查找 $str$ ,如果找到了，返回 $str$ 在已有 $string$ 类型的对象的下标，如果找不到则返回 $npos$ 。

? ? ? 对于函数的第 $2$ 个参数，如果不给定具体参数，则按照缺省参数从已有对象的值，从 $pos$ 位置开始查找。具体使用如下：

int main()
{
	string s1("hello world");
	string s2("hello");
	string s3("world");

	size_t pos1 = s1.find(s2);
	size_t pos2 = s1.find(s3);
	cout << pos1 << endl;
	cout << pos2 << endl;

	return 0;
}

运行结果如下：

对于两个参数的使用，例如从下标为 $4$ 的位置开始进行查找，即：

string s1("hello world");
string s3("world");
size_t pos3 = s1.find(s3, 4);
cout << pos3 << endl;

运行结果如下：

当不能查找到相应的内容时，例如：

	string s1("hello world");
	string s2("hello");
	
	size_t pos3 = s1.find(s2,6);
	cout << pos3 << endl;

?运行结果如下：

**3.2?size_t find (const char* s, size_t pos = 0) const:**

具体使用方法与 $3.1$ 中相同，只是参数有改变，本部分只给出一个应用，其他不再进行叙述：
?


	char a1[] = "hello";
	size_t pos5 = s1.find(a1, 0);
	cout << pos5 << endl;

运行结果如下：

**3.3?size_t find (const char* s, size_t pos, size_t n) const：**

本标题中函数的大致意思为：在已有的 $string$ 类型的第 $pos$ 位置，查找字符串 $s$ 的前 $n$ 个字符，例如：

char a2[] = "helloyou";

	size_t pos6 = s1.find(a2, 0, 5);
	cout << pos6 << endl;

运行结果如下：

对于上面的字符串 $a2$ ，如果是在已有的 $string$ 类型的对象中寻找前 $6$ 个字符，即在 $hello\,\, world$ 中寻找 $helloy$ ,即：

size_t pos6 = s1.find(a2, 0, 6);
	cout << "pos6" << ' ';
	cout << pos6 << endl;

运行结果为：

由于找不到匹配的内容，因此返回 $npos$ 。?

3.4?size_t find (char c, size_t pos = 0) const：

本部分标题中函数的大致意义为：从已有的 $string$ 类型的 $pos$ 位置开始寻找一个字符 $c$ ，如果不人为给定 $pos$ 的值，则默认从开头进行查找，具体使用方法如下：

string s6("abcdefg");
	size_t pos7 = s6.find('a');
	size_t pos8 = s6.find('a', 1);
	cout << "pos7:" << pos7 << endl << "pos8:" << pos8 << endl;

运行结果如下：

4. replace:

	
string& replace (size_t pos,  size_t len,  const string& str);
string& replace (iterator i1, iterator i2, const string& str);
	
string& replace (size_t pos,  size_t len,  const string& str,
                 size_t subpos, size_t sublen);
	
string& replace (size_t pos,  size_t len,  const char* s);
string& replace (iterator i1, iterator i2, const char* s);

string& replace (size_t pos,  size_t len,  const char* s, size_t n);
string& replace (iterator i1, iterator i2, const char* s, size_t n);

由于 $replace$ 的设计中，相似的部分过多，因此，文章只给出其中一个函数的使用

4.1 string& replace (size_t pos, ?size_t len, ?const string& str)：

本部分标题函数的大致意义为：从已有 $string$ 对象的 $pos$ 位置开始，把相隔 $len$ 个字符位置之内的内容，也就是 $[pos,len)$ 替换成 $str$ 。

具体使用方法如下：

string s1("hello world");
string s2("xx");

s1.replace(0, 2, s2);
cout << s1 << endl;

运行结果如下：

对于不同的场景，可以结合上方的函数来解决不同的问题，例如：

将 $"hello\, \, world\, \, hello\, \, everyone"$ 中的空格全部替换为 $*$ ：

string s2("hello world hello everyone");
	size_t pos = s2.find(' ');
	while (pos != s2.npos)
	{
		s2.replace(pos,1, "*");
		pos = s2.find(' ');
	}
	cout << s2 << endl;

运行结果如下：

但是这种方法每次循环都要从头去找空格所在的位置，并且 $replace$ 函数本身的作用原理就类似顺序表中的头插，效率过低，因此采用下面的方法：

string s4("hello world hello everyone");
	string s3;
	for (auto ch: s4)
	{
		if (ch == ' ')
		{
			s3 += '*';
		}
		else
		{
			s3 += ch;
		}
	}
	cout << s3 << endl;

运行结果如下：

文章来源:https://blog.csdn.net/2301_76836325/article/details/135649142
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！

C++(12)——string

1.insert:?

1.1??string& insert (size_t pos, const string& str)：

1.2??string& insert (size_t pos, const char* s)：

1.3??string& insert (size_t pos, const char* s, size_t n)：

1.4??string& insert (size_t pos, size_t n, char c)：

1.5??iterator insert (iterator p, char c)：

2. erase:

2.1?string& erase (size_t pos = 0, size_t len = npos): ?

2.2 iterator erase (iterator p)：

2.3?iterator erase (iterator first, iterator last)：

3. find:

3.1?size_t find (const string& str, size_t pos = 0) const:

3.2?size_t find (const char* s, size_t pos = 0) const:

3.3?size_t find (const char* s, size_t pos, size_t n) const：

3.4?size_t find (char c, size_t pos = 0) const：

4. replace:

4.1 string& replace (size_t pos, ?size_t len, ?const string& str)：

**1.2??string& insert (size_t pos, const char* s)：**

**1.3??string& insert (size_t pos, const char* s, size_t n)：**

2.1?string& erase (size_t pos = 0, size_t len = npos):
?

**3.2?size_t find (const char* s, size_t pos = 0) const:**

**3.3?size_t find (const char* s, size_t pos, size_t n) const：**