C++——string类

 

 
 

  ISO/ANSI C++98 标准通过添加 string 类扩展了 C++ 库，因此现在可以 string 类型的变量（使用 C++ 的话说是对象）而不是字符数组来存储字符串。string 类使用起来比数组简单，同时提供了将字符串作为一种数据类型的表示方法。
  要使用 string 类，必须在程序中包含头文件 string。
  在很多方面，使用 string 对象的方式与使用字符数组相同。

• 可以使用 C 风格字符串来初始化 string 对象。
• 可以使用 cin 来将键盘输入存储到 string 对象中。
• 可以使用 cout 来显示 string 对象。
• 可以使用数组表示法来访问存储在 string 对象中的字符。

 
  string 类使得能够使用对象来表示字符串，并定义了赋值运算符、关系运算符和加法运算符（用于拼接）。另外，string 类还提供了自动内存管理功能，因此通常不用担心字符串被保存前，有人可能会跨越数组边界或将字符串截短。
  string 类提供了许多方便的方法。例如，可以将一个 string 对象追加到另一个对象的后面，也可以将 C 风格的字符串，甚至 char 值追加到 string 对象的后面。对于接受 C 风格字符串参数的函数，可以使用 c_str() 方法来返回一个适合的 char 指针。
  string 类不仅提供了一组设计良好的方法来处理与字符串相关的工作（如查找子字符串），而且与 STL 兼容，因此，可以将 STL 算法用于 string 对象。
 
 

 
 

 
 

构造

方法	描述
string(const char *s)	将 string 对象初始化为 s 指向的 NBTS
string(size_type n, char c)	创建一个包含 n 个元素的 string 对象，其中每个元素都被初始化为字符 c
string(const string &str)	将一个 string 对象初始化为 string 对象 str（复制构造函数）
string()	创建一个默认的 string 对象，长度为 0（默认构造函数）
string(const char *s, size_type n)	将 string 对象初始化为 s 指向的 NBTS 的前 n 个字符，即使超过了 NBTS 结尾
template string(Iter begin, Iter end)	将 string 对象初始化为区间 [begin，end) 内的字符，其中 begin 和 end 的行为就像指针，用于指定位置，范围包括 begin 在内，但不包括 end
string(const string &str, string size_type pos = 0, size_type n = npos)	将一个 string 对象初始化为对象 str 中从位置 pos 开始到结尾的字符，或从位置 pos 开始的 n 个字符
string(string &&str) noexcept	C++11 新增，它将一个 string 对象初始化为 string 对象 str，并可能修改 str（移动构造函数）
string(initializer_list il)	C++11 新增，它将一个 string 对象初始化为初始化列表 il 中的字符

#include <iostream>
#include <string>
using namespace std;
int main()
{
  string str1("qw1");//#case1
  cout << "1: " << str1 << endl;
  
  string str2(3, 'q');//#case2
  cout << "2: " << str2 << endl;
  
  string str3(str1);//#case3
  cout << "3: " << str3 << endl;
  
  string str4;//#case4
  str4 = str1 + str2;
  cout << "4: " << str4 << endl;
  
  char s5[] = "123456789";
  string str5(s5, 4);//#case5
  cout << "5: " << str5 << endl;
  
  string str6(s5 + 2, s5 + 6);//#case6 也可以用string str6(&s5[2], &s5[5]); 
  cout << "6: " << str6 << "\n";
  
  string str7(str4, 3, 1);//#case7 
  cout << "7: " << str7 << endl;
  string str8(str4, 3);//#case7
  cout << "8: " << str8 << endl;
  return 0;
}

  构造函数 string(string &&str) 类似于复制构造函数，导致新创建的 string 为 str 的副本。但于复制构造函数不同的是，它不保证将 str 视为 const。
  构造函数 string(initializer_list il) 能够将列表初始化语法用于 string 类。如下所示是合法的：

string str1 = {'q', 'w', 'j', 'y'};
string str2 = {'1', '2', '3', '4'};

 
 

 
 

 
 

数据方法

方法	返回值
begin()	指向字符串第一个字符的迭代器
cbegin()	一个 const_iterator，指向字符串中的第一个字符（C++11）
end()	为超尾值的迭代器
cend()	为超尾值得 const_interator（C++11）
rbegin()	为超尾值的反转迭代器
crbegin()	为超尾值的反转 const_interator（C++11）
rend()	指向第一个字符的反转迭代器
crend()	指向第一个字符的反转 const_interator（C++11）
size()	字符串中的元素数，等于 begin() 到 end() 之间的距离
length()	与 size() 相同
capacity()	给字符串分配的元素数。这可能大于实际的字符数，capacity() - size() 的值表示在字符串末尾附加多少字符后需要分配更多的内存
max_size()	字符串的最大长度
data()	一个指向数组第一个元素的 const charT* 指针，其第一个 size() 元素等于 *this 控制的字符串中对应的元素，其下一个元素为 charT 类型的 char(0) 字符（字符串末尾标记）。当 string 对象本身被修改后，该指针可能无效
c_str()	一个指向数组第一个元素的 const charT* 指针，其第一个 size() 元素等于 *this 控制的字符串中对应的元素，其下一个元素是 charT 类型的 char T(0) 字符（字符串尾标识）。当 string 对象本身被修改后，该指针可能无效
get_allocator()	用于为字符串 object 分配内存的 allocator 对象的副本

 
 

内存方法	描述
void resize(size_type n)	如果 n>npos，将引发 out_of_range 异常；否则，将字符串的长度改为 n，如果 n<size()，则截短字符串，如果 n>size()，则使用 charT(0) 中的字符填充字符串
void resize(size_type n, charT c)	如果 n>npos，将引发 out_of_range 异常；否则，将字符串的长度改为 n，如果 n<size()，则截短字符串，如果 n>size()，则使用字符 c 填充字符串
void reserve(size_type res_arg = 0)	将 capacity() 设置为大于或等于 res_arg。由于这将重新分配字符串，因此以前的引用、迭代器和指针将无效
void shrink_to_fit()	C++11新增，请求让 capacity() 的值与 size() 相同
void clear() noexcept	删除字符串中所有字符
bool empty() const noexcept	如果 size() == 0，则返回 0

 
 

 
 

 
 

字符串存取

数据方法	描述
[ ] 运算符	① reference operator [ ] (size_type pos); 第一个 operator [ ] 方法使得能够使用数组表示法来访问字符串的元素，可用于检索或更改值 ② const_renference operator [ ] (size_type pos) const; 第二个 operator [ ] 方法可用于 const 对象，但只能用于检索值
at() 方法	① reference at (size_type n); ② const_refference at (size_type n) const; at() 方法提供了相似的访问功能，只是索引是通过函数参数提供的
substr() 方法	basic_string substr(size_type pos = 0, size_type n = npos) const; 返回原始字符串的子字符串——从 pos 开始，复制 n 个字符（或到字符串尾部）得到的。
front() 方法	C++11新增 front() 方法访问 string 的第一个元素，相当于 operator [ ] (0)
back() 方法	C++11新增 brack() 方法访问 string 的最后一个元素，相当于 operator [ ] (size() - 1)

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1("qwjy");
	cout << str1[2] << endl;
	str1[1] = 'y';
	cout << str1 << endl;
	const string str2("qyjy");
	cout << str2[1] << "\n\n";
	
	cout << str1.at(1) << endl;
	cout << str2.at(1) << "\n\n";
	
	cout << str1.substr() << endl;//默认从0到size()复制
	cout << str1.substr(0) << endl;//默认复制size()个字符
	cout << str1.substr(0,2) << endl;//复制从0开始的2个字符 
	return 0;
} 

  [ ] 运算符和 at() 方法差别在于（除语法差别外）：at() 方法执行边界检查，如果 pos >= size()，将引发 out_of_range 异常。pos 的类型为 size_type，是无符号的，因此 pos 的值不能为负；而 operator [ ] ( ) 方法不进行边界检查，因此，如果 pos >= size()，则其行为将是不确定的（如果 pos == size()，const 版本将返回空值字符的等价物）。
  可以在安全性（使用 at() 检测异常）和执行速度（使用数组表示）之间进行选择。
 
 

 
 

 
 

赋值

方法	描述
basic_string& operator=(const basic_string& str);	将一个 string 对象赋值给另一个 string str("qw"); string str1 = str;
basic_string& operator=(const charT* s);	将 C 风格字符串赋值给 string 对象 string str2 = "qw";
basic_string& operator=(charT c);	将一个字符赋给 string 对象 string str3 = 'q';
basic_string& operator=(basic_string&& str) noexcept; //C++	使用移动语义，将一个右值 string 对象赋给一个 string 对象
basic_string& operator=(initializer_list < charT >); //C++	使用初始化列表进行赋值 string str5 = {'q', 'w', 'j', 'y'};
basic_string& assign(const basic_string& str);	将一个string 对象 str 赋值给另一个 string str6; str6.assign(str);
basic_string& assign(const basic_string& str, size_type pos, size_type n);	将一个string 对象 str 的指定子串（从 pos 开始的 n 个字符）赋值给另一个 string str7; str7.assign(str, 1, 1);
basic_string& assign(const charT* s);	将 C 风格字符串 s 赋值给 string 对象 string str8; str8.assign("qw");
basic_string& assign(const charT* s, size_type n);	将 C 风格字符串 s 的指定子串（从 0 开始的 n 个字符）赋值给 string 对象 string str9; str9.assign("qw", 1);
basic_string& assign(size_type n, charT c);	将 n 个字符 c 赋值给 string 对象 string str10; str10.assign(5, 'q');
basic_string& assign(initializer_list< charT >);	使用初始化列表进行赋值 string str11; str11.assign({'q', 'w', 'j', 'y'});

 
 

 
 

 
 

字符串搜索

find()

find() 函数原型	描述
size_type find (const basic_string& str, size_type pos = 0) const noexcept;	.返回 str 在调用对象中第一次出现时的起始位置。搜索从 pos 开始（默认为 0），如果没有找到子字符串，将返回 npos string longer("QW is not very good, it is a waste."); string shorter("good"); size_type loc1 = longer.find(shorter); loc1 = longer.find(shorter, loc1 + 1);
size_type find (const charT* s, size_type pos = 0) const;	完成同样的工作，但它使用字符数组而不是 string 对象作为子字符串 size_type loc2 = longer.find("QW");
size_type find (const charT* s, size_type pos, size_type n) const;	完成同样的工作，但它只使用字符串 s 的前 n 个字符 size_type loc3 = longer.find("not", 2);
size_type find (charT c, size_type pos = 0) const noexcept;	功能与第一个相同，但它使用一个字符而不是 string 对象作为子字符串 size_type loc5 = longer.find('a');

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("qy");
	cout << str.find(str1) << endl;//#1: 从默认下标0开始查找
	cout << str.find(str1, 1) << endl;//#1: 从指定下标1开始查找 
	cout << str.find(str2) << "\n\n";//#1: 没有找到 
	
	cout << str.find("qw") << endl;//#2：从默认下标0开始查找 
	cout << str.find("qw", 10) << "\n\n";//#2：从指定下标10开始查找 
	
	cout << str.find("qw", 1) << endl;//#3：从指定下标1开始查找 
	cout << str.find("qw", 1, 10) << "\n\n";//#3：从指定下标1至其后10个字符之间查找 
	
	cout << str.find('q') << endl;//#4：从默认下标0开始查找 
	cout << str.find('q', 1);//#4：从指定下标1开始查找 
	return 0;
} 

 
 

rfind()

rfind() 函数原型	描述
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;	返回 str 在调用对象中最后一次出现时的起始位置。搜索从 pos 开始（默认为 npos），如果没有找到子字符串，将返回 npos
size_type rfind(const charT* s, size_type pos = npos) const;	完成同样的工作，但它使用字符数组而不是 string 对象作为子字符串
size_type rfind(const charT* s, size_type pos, size_type n) const;	完成同样的工作，但它只使用字符串 s 的后 n 个字符
size_type rfind(charT c, size_type pos = npos) const noexcept;	功能与第一个相同，但它使用一个字符而不是 string 对象作为子字符串

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("qy");
	cout << str.rfind(str1) << endl;//#1: 从默认下标npos开始向前查找
	cout << str.rfind(str1, 1) << endl;//#1: 从指定下标1开始向前查找 
	cout << str.rfind(str2) << "\n\n";//#1: 没有找到 
	
	cout << str.rfind("qw") << endl;//#2：从默认下标npos开始向前查找 
	cout << str.rfind("qw", 10) << "\n\n";//#2：从指定下标10开始向前查找 
	
	cout << str.rfind("qw", 1) << endl;//#3：从指定下标1开始向前查找 
	cout << str.rfind("qw", 25, 10) << "\n\n";//#3：从指定下标25至其前10个字符之间查找 
	
	cout << str.rfind('q') << endl;//#4：从默认下标npos开始向前查找 
	cout << str.rfind('q', 1);//#4：从指定下标1开始向前查找 
	return 0;
} 

 
 

find_first_of()

find_first_of() 函数原型	描述
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;	与对应 find() 方法的工作方法相似，但它们不是搜索整个子字符串，而是搜索子字符串中的字符首次出现的位置
size_type find_first_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_of(const charT* s, size_type pos = 0) const;
size_type find_first_of(charT c, size_type pos = 0) const noexcept;

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("not");
	//q是第一个在“qw”中的字符 
	cout << str.find_first_of(str1) << endl;//#1: 从默认下标0开始查找
	cout << str.find_first_of(str1, 1) << endl;//#1: 从指定下标1开始查找 
	cout << str.find_first_of(str2) << "\n\n";//#1: 从默认下标0开始查找
	
	cout << str.find_first_of("qw") << endl;//#2：从默认下标0开始查找 
	cout << str.find_first_of("qw", 10) << "\n\n";//#2：从指定下标10开始查找 
	
	cout << str.find_first_of("qw", 1) << endl;//#3：从指定下标1开始查找 
	cout << str.find_first_of("qw", 2, 10) << "\n\n";//#3：从指定下标2至其后10个字符之间查找 
	
	cout << str.find_first_of('q') << endl;//#4：从默认下标0开始查找 
	cout << str.find_first_of('q', 1);//#4：从指定下标1开始查找 
	return 0;
} 

 
 

find_last_of()

find_last_of() 函数原型	描述
size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;	与对应 rfind() 方法的工作方式相似，但它们不是搜索整个子字符串，而是搜索子字符串中出现的最后位置
size_type find_last_of(const charT* s, size_type pos, size_type n) const;
size_type find_last_of(const charT* s, size_type pos = npos) const;
size_type find_last_of(charT c, size_type pos = npos) const noexcept;

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("qy");
	//w是最后一个在“qw”中的字符 
	cout << str.find_last_of(str1) << endl;//#1: 从默认下标npos开始向前查找
	cout << str.find_last_of(str1, 1) << endl;//#1: 从指定下标1开始向前查找 
	cout << str.find_last_of(str2) << "\n\n";//#1: 从默认下标npos开始向前查找
	
	cout << str.find_last_of("qw") << endl;//#2：从默认下标npos开始向前查找 
	cout << str.find_last_of("qw", 10) << "\n\n";//#2：从指定下标10开始向前查找 
	
	cout << str.find_last_of("qw", 1) << endl;//#3：从指定下标1开始向前查找 
	cout << str.find_last_of("qw", 25, 10) << "\n\n";//#3：从指定下标25至其前10个字符之间查找 
	
	cout << str.find_last_of('q') << endl;//#4：从默认下标npos开始向前查找 
	cout << str.find_last_of('q', 1);//#4：从指定下标1开始向前查找 
	return 0;
} 

 
 

find_first_not_of()

find_first_not_of() 函数原型	描述
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;	与对应 find_first_of() 方法的工作方式相似，但它们搜索第一个不位于子字符串中的字符
size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_not_of(const charT* s, size_type pos = 0) const;
size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("qy");
	//空格是第一个没有在“qw”中出现的字符 
	cout << str.find_first_not_of(str1) << endl;//#1: 从默认下标0开始查找
	cout << str.find_first_not_of(str1, 1) << endl;//#1: 从指定下标1开始查找 
	//w是第一个没有在“qy”中出现的字符 
	cout << str.find_first_not_of(str2) << "\n\n";//#1: 从默认下标0开始查找
	
	cout << str.find_first_not_of("qw") << endl;//#2：从默认下标0开始查找 
	cout << str.find_first_not_of("qw", 10) << "\n\n";//#2：从指定下标10开始查找 
	
	cout << str.find_first_not_of("qw", 1) << endl;//#3：从指定下标1开始查找 
	cout << str.find_first_not_of("qw", 2, 10) << "\n\n";//#3：从指定下标2至其后10个字符之间查找 
	
	cout << str.find_first_not_of('q') << endl;//#4：从默认下标0开始查找 
	cout << str.find_first_not_of('q', 1);//#4：从指定下标1开始查找 
	return 0;
} 

 
 

find_last_not_of()

find_last_not_of() 函数原型	描述
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept	与对应 find_last_of() 方法的工作方式相似，但它们搜索的是最后一个没有在子字符串中的字符
size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
size_type find_last_not_of(const charT* s, size_type pos = npos) const;
size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str("qw is not very good, qw's English is too bad.");
	string str1("qw"), str2("qy");
	//.是最后一个没有出现在“qw”中的字符 
	cout << str.find_last_not_of(str1) << endl;//#1: 从默认下标npos开始向前查找
	cout << str.find_last_not_of(str1, 1) << endl;//#1: 从指定下标1开始向前查找 
	cout << str.find_last_not_of(str2) << "\n\n";//#1: 从默认下标npos开始向前查找
	
	cout << str.find_last_not_of("qw") << endl;//#2：从默认下标npos开始向前查找 
	cout << str.find_last_not_of("qw", 10) << "\n\n";//#2：从指定下标10开始向前查找 
	
	cout << str.find_last_not_of("qw", 1) << endl;//#3：从指定下标1开始向前查找 
	cout << str.find_last_not_of("qw", 25, 10) << "\n\n";//#3：从指定下标25至其前10个字符之间查找 
	
	cout << str.find_last_not_of('q') << endl;//#4：从默认下标npos开始向前查找 
	cout << str.find_last_not_of('q', 1);//#4：从指定下标1开始向前查找 
	return 0;
} 

 
 

 
 

 
 

比较方法和函数

方法	描述
int compare(const basic_string& str) const noexcept;	①第一个字符串位于第二个字符串之前（小于），则返回一个小于 0 的值 ②如果两个字符串相同，则它将返回 0 ③如果第一个字符串位于第二个字符串后面（大于），则返回一个大于 0 的值
int compare(size_type pos1, size_type n1, const basic_string& str) const;	与第一个方法相似，但它进行比较时，只使用第一个字符串中从位置 pos1 开始的 n1 个字符
int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2) const;	与第一个方法相似，但它使用第一个字符串中从 pos1 位置开始的 n1 个字符和第二个字符串中从 pos2 位置开始的 n2 个字符进行比较
int compare(const charT* s) const;	与第一个方法相似，但它将一个字符数组而不是 string 对象作为第二个字符串
int compare(size_type pos1, size_type n1, const charT* s) const;	与第三个方法相似，但它将一个字符数组而不是 string 对象作为第二个字符串
int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;	与第三个方法相似，但它将一个字符数组而不是 string 对象作为第二个字符串

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1("abcdefg"), str2("abcdefg"), str3("bcdefg"), str4("bcdf");
	cout << str1.compare(str2) << endl;//#1： str1和str2相同，返回0 
	cout << str1.compare(str3) << endl;//#1： str1小于str3，返回-1 
	cout << str3.compare(str1) << "\n\n";//#1： str3大于str1，返回1 
	
	cout << str1.compare(1, 6, str3) << "\n\n";//#2： str1中下标1后6个字符的字串与str3比较——相同0 
	
	cout << str1.compare(1, 3, str4, 0, 3) << "\n\n";//#3： str1中下标1后3个字符的字串与str4中下标0后3个字符的子串比较——相同 0
	
	cout << str1.compare("abcdefg") << "\n\n";//#4： str1与“abcdefg”比较——相同 0
	
	cout << str1.compare(1, 3, "bcd") << "\n\n";//#5： str1中下标1后3个字符的子串与“bcd”比较——相同 0
	
	cout << str1.compare(1, 3, "bcdf", 3) << "\n";//#6： str1中下标1后3个字符的子串与“bcdf”中下标0后3个字符的子串比较——相同0
	cout << str1.compare(1, 3, "bcdf", 2) << "\n\n";//#6： str1中下标1后3个字符的子串与“bcdf”中下标0后2个字符的子串比较——大于1 
	return 0;
} 

 
 
非成员比较函数是重载的关系运算符

运算符	描述
operator == ()	等于
operator < ()	小于
operator <= ()	小于等于
operator > ()	大于
operator >= ()	大于等于
operator != ()	不等于

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1("abcdefg"), str2("abcdefg"), str3("bcdefg"), str4("bcdf");
	printf("%d\n", str1 == str2);
	printf("%d\n", str1 < str2);
	printf("%d\n", str1 <= str2);
	printf("%d\n", str1 > str2);
	printf("%d\n", str1 >= str2);
	printf("%d\n", str1 != str2);
	
	return 0;
} 

 
 

 
 

 
 

字符串修改方法

追加和相加

  可以使用重载 += 运算符或 append() 方法将一个字符串追加到另一个字符串的后面。如果得到的字符串长于最大字符串长度。

+=运算符	描述
basic_string& operator += (const basic_string& str);	将 strinig 对象追加到 string 对象后面
basic_string& operator += (const charT* s);	将字符串数组追加到 string 对象后面
basic_string& operator += (charT c);	将单个字符追加到 string 对象后面

 
 

append() 方法原型	描述
basic_string& append(const basic_string& str);	在 string 字符串的末尾添加 string 对象 str
basic_string& append(const basic_string& str, size_type pos, size_type n);	在 string 字符串的末尾添加 string 对象 str 的子串,子串以 pos 索引开始，长度为 n
basic_string& append(const charT* s);	在 string 字符串的末尾添加字符数组 s
basic_string& append(const charT* s, size_type n);	在 string 字符串的末尾添加 n 个字符数组 s
basic_string& append(size_type n, charT c);	在 string 字符串的末尾添加 n 个字符 c
basic_string& append(InputIterator first, InputIterator last);	在 string 字符串的末尾添加以迭代器 first 和 last 表示的字符序列

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qw is not very good";
	string str2 = ", qw's English is too bad.";
	string str3 = "Hi,";
	
	str1.append(str2);
	cout << str1 << endl;
	
	str3.append(str2, 2, 2);
	cout << str3 << endl;
	
	str2.append(6, '6');
	cout << str2 << endl;
	
	return 0;
} 

 
 

其他方法	描述
void push_back(charT c);	将字符 c 添加到 string 字符串的末尾
operator + ()	能够拼接字符串

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qw is not very good";
	str1.push_back('.');
	cout << str1 << endl;
	
	string str2 = str1 + ", qw's English is too bad.";
	cout << str2 << endl;
	string str3 = str2 + str1;
	cout << str3 << endl;
	return 0;
} 

 
 

插入方法

方法	描述
basic_string& insert(size_type pos1, const basic_string& str);	在 pos1 位置插入一个 string 对象 str
basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n);	在 pos1 位置插入一个 string 对象的子串（从 pos2 开始的 n 个字符）
basic_string& insert(size_type pos, const charT* s);	在 pos 位置插入一个常量字符串
basic_string& insert(size_type pos, const charT* s, size_type n);	在 pos 位置插入常量字符串的一个子串（从 0 开始的 n 个字符）
basic_string& insert(size_type pos, size_type n, charT c);	在 pos 位置插入 n 个字符 c

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qy";
	string str2 = "wj";
	str1.insert(1, str2);
	cout << str1 << endl;
	
	string str3 = "qwjy";
	str1 = "qy";
	str1.insert(1, str3, 1, 2);
	cout << str1 << endl;
	
	string str4 = "w";
	str4.insert(0, "q");
	cout << str4 << endl;
	
	string str5 = "w";
	str5.insert(0, "qwqwqw", 1);
	cout << str5 << endl;
	
	string str6 = "w";
	str6.insert(0, 6, 'q');
	cout << str6 << endl;
	return 0;
} 

 
 

清除方法

方法	描述
basic_string& erase(size_type pos = 0, size_type n = npos);	从 pos 位置开始，删除 n 个字符或删除到字符串尾
iterator erase(const_iterator position);	删除迭代器位置引用的字符，并返回指向下一个元素的迭代器；如果后面没有其他元素，则返回 end()
iterator erase(const_iterator first, iterator last);	删除区间 [first, last) 中的字符，即从 first（包括）到 last（不包括）之间的字符；返回最后一个迭代器，该迭代器指向最后一个被删除的元素后面的一个元素
void pop_back();	删除字符串中的最后一个字符

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qw is not very good";
	str1.erase(0, 3);
	cout << str1 << endl;
	
	str1.pop_back();
	cout << str1 << endl;
	return 0;
} 

 
 

替换方法

方法	描述
basic_string& replace (size_type pos1, size_type n1, const basic_string& str);	用 str 替换指定字符串从起始位置 pos1 开始长度为 n 的字符
basic_string& replace (size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2);	用 str 的指定子串（给定起始位置 pos2 和长度 n2）替换从指定位置上的字符串(从起始位置 pos1 开始长度为 n 的字符)
basic_string& replace (size_type pos, size_type n1, const charT* s);	用字符数组 str 替换从起始位置 pos1 开始长度为 n 的字符
basic_string& replace (size_type pos, size_type n1, const charT* s, size_type n2);	用字符数组 str 指定位置（从起始位置 0 开始长度为 n2 的子串）替换从起始位置 pos1 开始长度为 n 的字符
basic_string& replace (size_type pos, size_type n1, size_type n2, charT c);	用重复 n2 次的 c 字符替换从指定位置pos 长度为 n1 的字符

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qy";
	string str2 = "w";
	str1.replace(1, 1, str2);
	cout << str1 << endl;
	
	string str3 = "qwjy";
	str1 = "qy";
	str1.replace(1, 1, str3, 1, 3);
	cout << str1 << endl;
	
	string str4 = "w";
	str4.replace(0, 1, "q");
	cout << str4 << endl;
	
	string str5 = "w";
	str5.replace(0, 1, "qwqwqw", 2);
	cout << str5 << endl;
	
	string str6 = "qqqqw";
	str6.replace(0, 4, 1, 'q');
	cout << str6 << endl;
	return 0;
} 

 
 

其他方法

其他方法	描述
size_type copy(charT* s, size_type n, size_type pos = 0) const;	将 string 对象或其中一部分复制到指定的字符串数组中。其中，s 指向目标数组，n 是要复制的字符数，pos 指出从 string 对象的什么位置开始复制。注意长度是否足够。
void swap(basic_string& str);	使用一个时间恒定的算法来交换两个 string 对象

#include<iostream>
#include<string>
using namespace std;
int main(){
	string str1 = "qw is not very good";
	string str2 = "qw's English is too bad.";
	char str3[60];
	str1.copy(str3, 30);
	cout << str3 << endl;
	char str4[60];
	str2.copy(str4, 7, 5);
	printf("%s\n", str4);
	
	str1.swap(str2);
	cout << str1 << endl;
	cout << str2 << endl;
	return 0;
} 

 
 

 
 

 
 

输出与输入

方法	描述
<< 和 >>	“<<” 和 “>>” 提供了 C++ 语言的字符串输入和字符串输出功能，到达文件尾、读取字符串允许的最大字符数或遇到空白字符后，输入将终止
getline()	getline() 从输入中读取字符，可以设置分界符（不设置，默认为“\n”）
c_str()	用转换函数c_str()，该函数将 string 类型的变量转换为一个 const 的字符串数组的指针

“<<” 和 “>>” 提供了 C++ 语言的字符串输入和字符串输出功能。

#include <iostream>
using namespace std;
int main()
{
  string str;
  cin >> str;//将输入读入到字符串 
  cout << str << endl;//输出 
  return 0;
}

  到达文件尾、读取字符串允许的最大字符数或遇到空白字符后，输入将终止（空白的定义取决于字符集以及 charT 表示的类型）。

还有一个常用的 getline() 函数，该函数的原型包括两种形式：

template <class CharT, class traits, class Allocator > basic_istream<CharT, traits>& getline (basic_istream<CharT, traits>& is, basic_string <CharT，traits, Allocator> & str);
//上述原型包含 2 个参数：第 1 个参数是输入流；第 2 个参数是保存输入内容的字符串
template <class CharT, class traits, class Allocator > basic_istream<CharT, traits>& getline (basic_istream<CharT, traits>& is, basic_string <CharT，traits, Allocator> & str, charT delim);
//上述原型包含 3 个参数：第 1 个参数是输入流，第 2 个参数保存输入的字符串，第 3 个参数指定分界符。

  这个函数将输入流 is 中的字符读入到字符串 str 中，直到遇到定界字符 delim、到达文件尾或者到达字符串的最大长度。delim 字符将被读取（从输入流中删除），但不被存储。

#include <iostream>
using namespace std;
int main()
{
  string str1, str2;
  getline(cin, str1);
  getline(cin, str2, '.');//以“.”为分界符 
  cout << "str1: " << str1 << endl;
  cout << "str2: " << str2 << endl;
  return 0;
}

也可以用转换函数c_str()，该函数将 string 类型的变量转换为一个 const 的字符串数组的指针。

#include <iostream>
using namespace std;
int main()
{
  string str;
  getline(cin, str);
  printf("%s", str.c_str()) ;
  return 0;
}