[C++知识库]c++之string类

本文来自于c++标准库文件,所有示例均在Visual Studio17版本上验证通过;

表示一个可变成字符串;

常见构造写法

string str("123456"); //123456
string str1("1234567", 4);//存储1234567到str1中,最多存储4个; 结果:234
string str2("1234567", 2, 4);//将"1234567"的第2位作为开始,存入str2中,最多存储4个; 结果:3456
string str3(10,'A');//存储10个A到str3中;  结果:AAAAAAAAAA
string str4;//空串

常见成员函数

1. 拼接("+="和append)

string str("abc"); //abc
str.append("de"); //abcde
str += "fg"; 	 //abcdefg

string s1("abc");//abc
string s2 = "def";//def
string s3 = s1 + s2;//abcdef
string s4 = s1 + "and" + s2;//abcanddef

//string s5 = "abc" + "def"; 语法错误
string s6 = "AB" + s1 + "DE";//ABabcDE
//string s7 = "AB" + "DE" + s1;语法错误
结论:两个字符串不能挨着相加;

2. assign

作用:对string对象赋值, 返回对象自身的引用;

string str("abc");//abc

/*原型: basic_string& assign(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)*/
str.assign(10, 'A');//AAAAAAAAAA

/*原型: basic_string& assign(_In_z_ const _Elem * const _Ptr)*/
str.assign("hello");//hello

/*原型:	basic_string& assign(_In_reads_(_Count) const _Elem * const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)*/
str.assign("hello", 4 );//hell

/*原型:	basic_string& assign(const basic_string& _Right, const size_type _Roff, size_type _Count = npos)*/
//将hello转成了string对象;
str.assign("hello",2,3);//llo

string str1;
/*原型:	basic_string& assign(const basic_string& _Right)*/
str1.assign(str);

/*原型:	basic_string& assign(const basic_string& _Right, const size_type _Roff, size_type _Count = npos)*/
str1.assign(str,2,4);

3. at

作用: 返回偏移量所在的引用(或const 引用);

string str("1234567");

/*原型1: reference at(const size_type _Off)*/
/*原型2: const_reference at(const size_type _Off) const*/
auto ret = str.at(3);
cout << ret << " " << str.c_str() << endl;//4 1234567

4. back()

作用:返回最后一个元素的引用(或const引用);

/*原型1：reference back()
		{  
			return (*(end() - 1)); 从源码知道,那么end()函数将返回的是最后一个元素后面的位置!!!
		}
*/
/*原型2: const_reference back() const*/
string str("1234567");
auto ret = str.back();
cout << ret << " " << str.c_str() << endl;//7 1234567

5. begin()

作用:返回开头的迭代器(或const迭代器);

string str("1234567");
string::iterator iter = str.begin();
//string::const_iterator iter = str.begin();
cout << *iter<< endl; //1

6. end()

作用: 返回最后一个元素的后一个位置的迭代器(或const迭代器)

string str("1234567");

/*原型1： iterator end() noexcept*/
/*原型2: const_iterator end() const noexcept*/
string::iterator iter = str.end();
cout <<   *(iter-1) << endl;//7

7. cbegin()

作用:等同于begin的const版本；返回开始位置的const迭代器;

string str("1234567");
	
/* const_iterator cbegin() const noexcept
   {	
	  return (begin());//调用begin的const重载函数;
   }
*/	
string::const_iterator b =  str.cbegin();
cout << "const cbegin = " << *b << endl;//1

8.cend ()

作用:等同于end()的const版本;返回最后一个元素所在位置下一位置的迭代器;

/*const_iterator cend() const noexcept
 {	
   return (end());
 }*/
string::const_iterator e =  str.cend();
cout << "iter cend = " << *(e-1) << endl;

9. capacity()

作用:返回已分配存储的当前长度;

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

10. clear()

作用: 擦除(清空)

string str("1234567");
str.clear(); //""

str += "clear";//clear

11. compare

作用:比较字符串；
返回值:
(1) 小于0,当前字符串小;
(2) 等于0,两个字符串相同;
(3) 大于0,当前字符串大;

string str("1234567");

/*原型：int compare(_In_z_ const _Elem * const _Ptr) const noexcept */
int com = str.compare("12345678");//-1
com = str.compare("1234567");//0
com = str.compare("123456");//1

/*原型：int compare(const size_type _Off, const size_type _N0, _In_z_ const _Elem * const _Ptr) const*/
//用str字符串的[0,3]与"1ab456"比较;
com = str.compare(0, 3, "1ab456");//-1

/*原型：int compare(const size_type _Off, const size_type _N0, const basic_string& _Right,
		const size_type _Roff, const size_type _Count = npos) const*/
//用str字符串的[0,3]与"112456"的[0,3]比较;
com = str.compare(0, 3, "112456",0,3);//-1

12. copy

/*原型: size_type copy(_Out_writes_(_Count) _Elem * const _Ptr,size_type _Count, const size_type _Off = 0) const */
//copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)

string str("1234567");
char ptr[16] = {0};
int retcopy = str.copy(ptr,5,0);//将str的偏移量为0,长度为5字节数据复制到ptr中;返回实际复制的数量;
cout <<"cppy=" << retcopy << "  " << str.c_str() << "  "<<  ptr <<  endl;

13. crbegin() 和 crend()

作用:crbegin 返回const反向开始位置迭代器；也就是正向最后一个元素位置;
crend 返回const反向结束位置下一位置迭代器; 也就是正向开始元素前一个位置;

/* 原型：const_reverse_iterator crbegin() const noexcept */
string str("1234567");

string::const_reverse_iterator iterrb = str.crbegin();
cout << *iterrb << endl;//7

string::const_reverse_iterator iterre = str.crend();
cout << *(iterre-1) << endl;//1

14. c_str() 和 data()

string str("1234567");

//返回指向不可变数组的指针;相当于string转const char *;从源码看两者功能一样;
//网上有很多说两者略微有差异,和标准有关;具体不深究;
cout << str.c_str() << endl;//1234567
cout << str.data() << endl;//1234567

15. erase

作用:擦除指定区间/位置的元素;

/* 原型1： basic_string& erase(const size_type _Off = 0) */
string s1("1234567");
s1.erase(2); //擦除起始位置为2后所有元素;
cout << s1.c_str() << endl;//12

/*原型2: 	basic_string& erase(const size_type _Off, size_type _Count) */
string s2("1234567");
s2.erase(2,4); //擦除[2,2+4]区间元素;
cout << s2.c_str() << endl; //127
	
/*原型3： iterator erase(const const_iterator _Where) */
string s3("1234567");
string::const_iterator ib = s3.begin();
s3.erase(ib);//擦除ib位置的元素 
cout << s3.c_str() << endl; //234567
	
/*原型4： iterator erase(const const_iterator _First, const const_iterator _Last) */
string s4("1234567");
string::const_iterator ib1 = s4.begin();
string::const_iterator ie1 = ib1 + 4;
s4.erase(ib1,ie1);//擦除[ib1,ie1)区间元素;
cout << s4.c_str() << endl; //567

16. empty()

作用：测试string对象是否为空;

string str;
if (str.empty()) {
	cout << "str is empty" << endl;
}else {
	cout << "str no empty" << endl;
}

17. find

作用:从开始位置开始查找某一字符或字符串;成功返回出现的位置,失败返回-1;

/*原型1: size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept */
string str("1234567");
int ret = str.find('5',3);//从3位置开始查找'5',返回找到的位置;  结果为4；

/*原型2：size_type find(_In_z_ const _Elem * const _Ptr, const size_type _Off = 0) const noexcept */
ret = str.find("34", 0);//从0位置查找"34", 返回实际查找的位置2;

/*原型3： size_type find(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off, const size_type _Count) 
const noexcept*/
ret = str.find("3456", 1, 2);//从1开始查找"3456"前2个,也就是"34", 返回结果为2

/*原型4:  size_type find(const basic_string& _Right, const size_type _Off = 0) const noexcept */
string s("34");
ret = str.find(s,1);//2

18. find_first_of

作用:查找string串中任意一个字符；

string str("1234567");
/*size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept */
int ret = str.find_first_of('5',2);//从偏移位置2开始查找'5'所在位置; 返回值为4;

/* size_type find_first_of(_In_z_ const _Elem * const _Ptr, const size_type _Off = 0)*/
ret = str.find_first_of("856",2);//从偏移位置2开始查找"856"中任意元素;  找到返回位置为4；

/*size_type find_first_of(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,
	const size_type _Count) const noexcept*/
ret = str.find_first_of("8256", 2, 2);//从偏移位置2开始查找"8256"前2个; 相当于从str中的3开始往后查找82;返回-1；

/*size_type find_first_of(const basic_string& _Right, const size_type _Off = 0) const noexcept*/
string s1("45");
ret = str.find_first_of(s1, 2);//从偏移量为2开始查找s1串中元素; 返回找到的位置为3；

19. find_first_not_of

作用:查找string中任意字符,找到元素不相等的位置即返回;

string str("1234567");
/*原型1: size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept 
 // look for non _Ch at or after _Off
*/
int ret = str.find_first_not_of('4', 1);//1

/*原型2：size_type find_first_not_of(_In_z_ const _Elem * const _Ptr, size_type _Off = 0) const noexcept
  // look for one of [_Ptr, <null>) at or after _Off
*/
ret = str.find_first_not_of("56", 2);//2

/*原型3： size_type find_first_not_of(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,
		const size_type _Count) const noexcept 
  //look for none of [_Ptr, _Ptr + _Count) at or after _Off
*/
ret = str.find_first_not_of("2345", 1, 2);//3

/*原型4：  size_type find_first_not_of(const basic_string& _Right, const size_type _Off = 0) const noexcept */
// look for none of _Right at or after _Off
string s1("34");
ret = str.find_first_not_of(s1, 2);//4

20. find_last_of

作用:从偏移量位置开始反向查找子串字符(或子串)出现的位置;

string str("12345671234567");

/*原型1: size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept */
int ret = str.find_last_of('4', 13);//在偏移量13处往前查找字符'4';  结果为9；

/*原型2: size_type find_last_of(_In_z_ const _Elem * const _Ptr, const size_type _Off = npos) const noexcept */
ret = str.find_last_of("64", 13);//从偏移量13处开始往前查找字符串"34"任意元素位置; 结果返回12；

/*原型3: size_type find_last_of(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,
	const size_type _Count) const noexcept*/
ret = str.find_last_of("1234", 13, 2);//从偏移量13处开始往前查找子串"1234"前两个字符,即"12"所在位置;结果返回8；

/*原型4: size_type find_last_of(const basic_string& _Right, size_type _Off = npos) const noexcept*/
string s1("34");
ret = str.find_last_of(s1, 8);//从偏移位置8开始往前查找s1中的字符串; 结果返回3；

21. find_last_not_of

作用:从偏移位置开始反向查找第一个不属于子串任何字符的位置,成功返回该位置,失败-1；

string str("12345671234567");

/*size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept*/
int ret = str.find_last_not_of('5');//13

/* size_type find_last_not_of(_In_z_ const _Elem * const _Ptr, const size_type _Off = npos) const noexcept */
ret = str.find_last_not_of("34", 10);//8

/*size_type find_last_not_of(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,
	const size_type _Count) const noexcept*/
ret = str.find_last_not_of("345", 4, 2);//4

string s("45");
/*size_type find_last_not_of(const basic_string& _Right, const size_type _Off = npos)*/
ret = str.find_last_not_of(s, 4);//2

22. front()

作用: 返回第一个元素的引用;

string str("hello");

//版本1：reference front()
//版本2：const_reference front() const
auto &s = str.front(); //h

23. insert

作用:在指定位置插入值；

/*原型1: iterator insert(const const_iterator _Where, const _Elem _Ch)*/
string str("hello");
str.insert(str.cbegin(), 'h');//在str开始处插入字符'h'; 结果为:hhello

/*原型2: iterator insert(const const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)*/
string str("hello");
str.insert(str.cbegin(), 2, 'h');//在str开始处插入3个字符'h'; 结果为:hhhello

/*原型3：basic_string& insert(const size_type _Off, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)*/
string str("hello");
str.insert(5, 2, 'b');//在str位置5处插入2个字符'b'; 结果为:hellobb

/*原型4:basic_string& insert(const size_type _Off, _In_z_ const _Elem * const _Ptr)*/
string str("hello");
str.insert(0, "add");//在str位置0处插入字符串"add"; 结果为:addhello

/*原型5：basic_string& insert(const size_type _Off, _In_reads_(_Count) const _Elem * const _Ptr,
		_CRT_GUARDOVERFLOW const size_type _Count)*/
string str("hello");
str.insert(5, "world", 2);//在str位置5处插入字符串"world"前2个元素; 结果为：hellowo

/*原型6：basic_string& insert(const size_type _Off, const basic_string& _Right, const size_type _Roff, size_type _Count = npos)*/
string str("hello");
string s("world");
str.insert(5, s, 2, 3);//从str的位置5处插入 s的2开始长度为3的字符; 结果为:hellorld

/*原型7：basic_string& insert(const size_type _Off, const basic_string& _Right)*/
string str("hello");
string s("world");
str.insert(5, s);//在str位置5处插入s;

/*原型8：iterator insert(const const_iterator _Where, const _Iter _First, const _Iter _Last)*/
string str("hello");
string s("world");
str.insert(str.cbegin(), s.begin(), s.end());//从str开始位置插入 s的开始到结束字符; 结果为:worldhello

24. length

作用:返回序列的长度,不包含’\0’;

string str("hello");
cout << str.size() << endl;//5
cout << str.length() << endl;//5
//size()和length源码相同;

25. max_size()

作用:返回序列最大可能的大小;

26. =,+=,[ ]

string str("hello");
str += "world";//helloworld

str = "insert"; 
cout << str.c_str() << endl;//insert

for (int i = 0; i < str.length(); i++) {
	printf(" str[%d] = %c \n",i, str[i]);//分别为i,n,s,e,r,t
}

27 push_back,pop_back

作用:添加一个字符/移除最后一个字符;

string str("hello");
str.push_back('a');//helloa

str.pop_back();
str.pop_back();//hell

28. rbegin,rend();

作用:返回反向迭代器开始/结束位置

string str("hello");
	
string::reverse_iterator riterb = str.rbegin();
cout<< *riterb << endl;//o
string::reverse_iterator ritere = str.rend();//指向的是开始元素的前一个位置;
cout << *(ritere-1) << endl;//h

29. replace

string str("hello");
string s("world");
/*原型:basic_string& replace(const const_iterator _First, const const_iterator _Last,
		const _Iter _First2, const _Iter _Last2)*/
str.replace(str.begin(), str.begin() + 2, s.begin(), s.begin() + 2);//wollo
cout << str.c_str() << endl;

/*basic_string& replace(const const_iterator _First, const const_iterator _Last,
	const size_type _Count, const _Elem _Ch)*/
str.replace(str.begin(), str.begin() + 2, 2, 'w');//wwllo
cout << str.c_str() << endl;

str.replace(str.begin(), str.begin() + 2, "wo");//wollo
cout << str.c_str() << endl;

/*basic_string& replace(const const_iterator _First, const const_iterator _Last,
	_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Count)*/
str.replace(str.begin(), str.begin() + 2, "replace", 2);//rello
cout << str.c_str() << endl;

/*basic_string& replace(const const_iterator _First, const const_iterator _Last, const basic_string& _Right)*/
string s1("he");
str.replace(str.begin(), str.begin() + 2, s1);//hello
cout << str.c_str() << endl;

/*basic_string& replace(const size_type _Off, size_type _N0, const size_type _Count, const _Elem _Ch)*/
// replace [_Off, _Off + _N0) with _Count * _Ch
str.replace(1, 3, 2, 'a');//haao
cout << str.c_str() << endl;

/*basic_string& replace(const size_type _Off, const size_type _N0, _In_z_ const _Elem * const _Ptr)*/
// replace [_Off, _Off + _N0) with [_Ptr, <null>)
str.replace(2, 3, "hello");//hahello
cout << str.c_str() << endl;

/*basic_string& replace(const size_type _Off, size_type _N0,
	_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Count)*/
// replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
str.replace(2, 3, "hello", 2);//hahelo
cout << str.c_str() << endl;

str.replace(2, 3, s, 0, 2);//hawoo
cout << str.c_str() << endl;

/*basic_string& replace(const size_type _Off, const size_type _N0, const basic_string& _Right)*/
// replace [_Off, _Off + _N0) with _Right
str.replace(2, 3, s);//haworld
cout << str.c_str() << endl;

30. reserve

决定存储分配的最小长度,影响capacity;string内存分配按照:(n*16-1)分配

string str("hello");
string s("world");

str.reserve(20);
//具体参考:https://blog.csdn.net/qq_34977392/article/details/78239892

31. resize

决定新长度,根据需要使用_Ch元素填充;

string str("hello");
str.resize(2);
cout << str.length() << " "<< str.c_str() << endl; //2 he

str.resize(12, 'a');
cout << str.length() << " " << str.c_str() << endl; //heaaaaaaaaaa

32. rfind

string str("hello");

/*size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept // strengthened*/
//在off前寻找_ch
int ret = str.rfind('e', 3); //1

/*size_type rfind(_In_z_ const _Elem * const _Ptr, const size_type _Off = npos)*/
// look for [_Ptr, <null>) beginning before _Off
ret = str.rfind("lo", 3);//3

/* size_type rfind(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,
	const size_type _Count) const noexcept*/
	// look for [_Ptr, _Ptr + _Count) beginning before _Off
ret = str.rfind("llo", 5, 2);//2

string s("lo");
/*size_type rfind(const basic_string& _Right, const size_type _Off = npos) const noexcept*/
// look for _Right beginning before _Off
ret = str.rfind(s, 5);//3

33. substr

作用: 查找子串

string str("hello");
/* basic_string substr(const size_type _Off = 0, const size_type _Count = npos) const*/
string s = str.substr(1, 3);//ell
cout << s.c_str() << endl;