【C++ STL】 string 容器基本概念和成员函数用法

string 容器基本概念和成员函数用法

一：string 概念和操作

1. string 概念

string容器本质上是一个c++类型的类，同时也是一个类模板。它提供了许多成员函数和运算符重载，封装了C++中对字符串的常见操作和功能，提供了更高级的字符串处理能力，并且隐藏了底层的实现细节，使得字符串的操作更加方便和安全。

2. string 操作

1. 字符串类型：string 是 C++ 中用于表示字符串的数据类型，它可以存储任意长度的字符序列。
2. 字符串长度：string 的长度是指其中字符的数量，可以通过成员函数 length() 或 size() 获取字符串的长度。
3. 字符访问：可以通过下标运算符 [] 或成员函数 at() 来访问字符串中的单个字符。
4. 字符串拼接：使用操作符 + 可以将两个字符串拼接在一起，也可以使用成员函数 append() 进行字符串的追加。
5. 字符串比较：可以使用比较操作符 ==、!=、<、<=、>、>= 对字符串进行比较，比较的是字符的ASCII码值。比较的规则是从左到右逐个比较字符，直到找到两个不相等的字符或者其中一个字。
6. 子串提取：可以使用成员函数 substr() 提取字符串的子串。
7. 字符串查找：可以使用成员函数 find() 和 rfind() 查找字符串中的子串。
8. 字符串替换：可以使用成员函数 replace() 替换字符串中的子串。
9. 字符串插入和删除：可以使用成员函数 insert() 和 erase() 在字符串中插入和删除字符或子串。
10. 字符串转换：可以使用成员函数 c_str() 将 string 转换为 C 风格的字符串，也可以使用 std::stoi、std::stof 等函数进行字符串到数值类型的转换。
11. 使用 getline 读取一整行：getline(cin,s); 从 cin 标准输入流中读取一行文本赋给字符串 s ,返回s。

二：string成员函数使用

1. string 初始化

函数原型：

1. string(); // 创建空字符串
2. string(const char* str); // 字符串初始化
3. string(const string& str); // 使用string对象初始化另一个string对象
4. string(int n,char c); // 使用n个字符c初始化

代码示例：

//字符串的构造函数
void test01(){
	string str1; //默认构造 无参构造
	cout<<str1<<endl;
	
	// str2 初始化 str
	const char* str = "hello world";
	string str2(str); 
	cout<<str2<<endl; 
	
	//str3初始化str2
	string str3(str2); 
	cout<<str3<<endl;
	
	//初始化4个字符v的字符串
	string str4(4,'v'); 
	cout<<str4<<endl;
}

2. string 赋值

（1）operator= 运算符重载

函数原型

// char* 类型字符串赋值给当前字符串
1. string& operator=(const char* s);  
// 字符串s赋值给当前的字符串 ,"const string &s" 是一个函数参数的声明，表示接收一个名为 "s" 的字符串引用，并且使用了 const 修饰符。
2. string& operator=(const string &s); 
// 字符c赋值给当前的字符串
3. string& operator=(char c);     

代码示例：

void test(){
	// 字符串"hello"赋值给 string 字符串
	string str1 = "hello";
	cout<<str1<<endl;
	
	//2 字符串str2赋值给当前的字符串
	str1 = str2;
	cout<<str1<<endl;
	
	//3 字符w赋值给当前的字符串
	string str2;
	str2 = "w";
	cout<<str2<<endl;
}

（2）assign() 函数重载

函数原型

// 字符串s赋值给当前字符串
4. string assign(const char* s);       
// 字符串s前n个字符赋值给当前字符串对象
5. string assign(const char* s,int n); 
// string类型的字符串赋值给当前字符对象
6. string assign(const string& s);   
// 将n个字符c赋值给当前字符串对象
7. string assign(int n,char c);       

代码示例：

void test02(){
	// 字符串赋值给当前字符串
	string str3;
	str3.assign("hello c");
	cout<<str3<<endl;
	
	// 字符串"hello"前n个字符赋值给当前字符串str5
	string str5;
	str5.assign("hello",3);
	cout<<str5<<endl;
	
	// string 类型的字符串赋值给当前字符对象
	string str4;
	str4.assign(str3);
	cout<<str4<<endl;
	
	// 将n个字符v赋值给当前字符串对象
	string str6;
	str6.assign(10,'v');
	cout<<str6<<endl;	
}

3. string 字符串拼接

（1）operator+= 运算符重载

函数原型：

// 将一个 C 风格的字符串（以 null 结尾的字符数组）连接到当前字符串的末尾，并返回一个引用，指向连接后的当前字符串。
1. string& operator+=(const char* str); 
// 将单个字符连接到当前字符串的末尾，返回的是一个引用，指向连接后的当前字符串。 
2. string& operator+=(const char c);  
// 将另一个字符串连接到当前字符串的末尾，返回一个引用，指向连接后的当前字符串。
3. string& operator+=(const string& str); 

代码示例：

void test(){
	// C 类型字符串拼接
	string str1 = "hello";
	str1 += "vv"; 
	cout<<str1<<endl;
	
	// 将单个字符连接到当前字符串的末尾
	char c = 'c';
	str1 += c; 
	cout<<str1<<endl;
	
	// 将另一个字符串连接到当前字符串的末尾
	string str2 = "world";
	str1 += str2; 
	cout<<str1<<endl;
}

（2）append() 函数重载

函数原型：

// 将一个C风格的字符串连接到当前字符串的末尾。该函数会修改当前字符串对象，并返回一个引用，指向连接后的当前字符串。
4. string& append(const char* str); 
// 字符串s的前n个字符来连接到字符串的末尾。
5. string& append(const char* s,int n); 
// 将字符串连接到当前字符串末尾，返回一个string引用。
6. string& append(const string& str); 
// 将字符串s从pos位置开始的n个字符连接到字符串结尾。
7. string& append(const string& s,int pos,int n);

代码示例：

//拼接操作 
void test03()
{
	// 将一个C风格的字符串连接到当前字符串的末尾
	str1.append("and");
	cout<<str1<<endl;
	
	// 字符串"and"的前2个字符来连接到字符串的末尾
	str1.append("and",2); 
	cout<<str1<<endl;
	
	// 将字符串连接到当前字符串末尾
	str1.append(str2); 
	cout<<str1<<endl;
	
	//将字符串str2 从1位置开始的2个字符连接到字符串结尾。
	str1.append(str2,1,2); 
	cout<<str1<<endl;
}

4. string 查找和替换

（1）查找指定字符串

函数原型：

// 查找str第一次出现的位置，从pos开始查找。
1. int find(const string& str, int pos = 0) const;   
// 查找s第一次出现的位置，从pos开始查找。
2. int find(const char* s, int pos = 0) const;       
// 从pos位置查找s的前n个字符第一次出现的位置。
3. int find(const char* s, int pos, int n) const;    
//从pos位置查找c字符第一次出现的位置。
4. int find(char c, int pos = 0) const;              
//查找str最后一次的位置，从pos开始查找。
5. int rfind(const string& str, int pos = npos) const; 
//查找s最后一次出现的位置，从pos开始查找。
6. int rfind(const char* s, int pos = npos) const;    
//查找s的前n个字符最后一次出现的位置，从pos开始查找。
7. int rfind(const char* s, int pos, int n) const;   
//查找字符c最后一次出现的位置，从pos位置开始查找。
8. int rfind(char c, int pos = npos) const;          

find 和 rfind 的区别:

rfind是从右往左查找，find是从左往右查找。
例如：
对于字符串 “Hello, Hello, Hello”：
find(“Hello”) 返回的是 0，即第一个 “Hello” 的位置。
rfind(“Hello”) 返回的是 12，即最后一个 “Hello” 的位置。
但是字符串都是从左往右进行匹配的，匹配顺序和find方向一样。

代码示例：

void test(){
	//查找
	string str1 = "zhangsan@123123.com";
	int pos = str1.find("zhangsan");
	if(pos == -1){
		cout<<"未查找到"<<endl;
	}
	else{
		cout<<"pos = "<<pos<<endl; // 结果0，因为开始就找到了
	}
	int pos1 = str1.rfind("123");
	cout<<"pos1 = "<<pos1<<endl;   // 结果: 12 
	// 从左到右第二个123，也是最后一个123字符串
}

（2）指定位置替换字符串

函数原型：

//替换从pos开始的len个字符为字符串str。
9. string& replace(int pos, int len, const string& str); 
//替换从pos开始的len个字符为字符串s。
10. string& replace(int pos, int len, const char* s);  

代码示例：

void test04()
{
	//替换
	string str2 = "world";
	str1.replace(2,3,str2); //结果：zhworldsan@123123.com
	cout<<str1<<endl;
	
	str1.replace(3,2,"ewq");//结果：zhwewqldsan@123123.com
	cout<<str1<<endl;
}

5. string 字符串比较

函数原型：

注：字符串比较是按照字符串的ascii码表来进行比较：== 返回 0；> 返回 1 ； < 返回 -1；

// 用于比较当前字符串和另一个字符串 s 的大小关系
int compare(const string& s) const;
// 比较当前字符串和一个以 null 结尾的字符数组 s（C 风格字符串）的大小关系。
int compare(const char* s) const;

代码示例：

//字符串比较
void test05()
{
	string str1 = "hello";
	string str2	= "xello";
	
	// string 字符串比较
	int res = str1.compare(str2); 
	cout << res << endl; // 结果: 1
	
	// string与c风格字符串比较
	int res = str2.compare("xhello"); 
	cout << res << endl; // 结果: -1
} 

6. string 字符串存取和修改

函数原型：

// 通过[n]方式获取字符
char& operator[](int n);
// 通过at(n)方式取字符
char& at(int n); 

代码示例：

void test06()
{
	string str1 = "hello";
	//通过 operator[] 来获取数据 
	for(int i=0;i<str1.size();i++){
		cout<<str1[i]<<" ";	
	}
	cout<<endl;
	
	//通过at(i) 来获取数据 
	for(int i=0;i<str1.size();i++){
		cout<<str1.at(i)<<" ";	
	}
	cout<<endl;
	
	// 对数据进行修改操作
	str1[0] = 'x';
	str1.at(1) = 'x';
	for(int i=0;i<str1.size();i++){
		cout<<str1[i]<<" ";	
	}
}

7. string 插入删除

函数原型：

// 在当前字符串的指定位置 pos 处插入一个 C 风格字符串 s。返回插入后的字符串的引用
1. string& insert(int pos,const char* s); 
// 在当前字符串的指定位置 pos 处插入另一个字符串 str。返回插入后的字符串的引用。
2. string& insert(int pos,const string& str);
//在当前字符串的指定位置 pos 处插入 n 个字符 c。返回插入后的字符串的引用。
3. string& insert(int pos,int n,char c);
//从当前字符串的指定位置 pos 开始，删除 n 个字符。如果不提供 n 的值，默认删除从 pos 开始到字符串末尾的所有字符。返回删除后的字符串的引用。
4. string& erase(int pos,int n = npos);

代码示例：

//string 插入和删除操作
void test07(){
	// insert(int pos,const char* s); 
	string str1 = "hello";
	str1.insert(1,"000");
	cout << str1 << endl; // h000ello
	
	// insert(int pos,const string& str);
	string str2 = "x";
	str1.insert(3,str2);
	cout << str1 << endl; // h00x0ello 
	
	// insert(int pos,int n,char c);
	char c = 'c';
	str1.insert(0,3,c);
	cout << str1 << endl; // ccch00x0ello
	
	// erase(int pos,int n = npos);
	str1.erase(1,3); //删除1-3之间的值 -> "hello" 
	cout << str1 << endl; 
}

8. string 提取子串

函数原型：

//返回由pos开始的n个字符组成的字符串
string substr(int pos=0, int n = npos) const; 

代码示例：

// string 子串提取操作
void test08()
{
	string str1 = "abcdef";
	string str1_sub = str1.substr(1,2);
	cout << str1_sub <<endl;
	
	//开发的实际操作，一般都是这样用
	string email = "zhangsan@qq.com";
	int pos = email.find("@");
	cout<<pos<<endl;
	string userName = email.substr(0,pos); // 提取0-pos之间的字符串为新字符串（子串）
	cout<< userName <<endl; // zhangsan
}

9. string 字符串转换

常见的类型转换方式：

1. 字符串转整数：

• 使用 stoi 函数可以将字符串转换为整数类型。
• 使用 stol、stoll 函数可以将字符串转换为长整数类型。
• 使用 stof、stod、stold 函数可以将字符串转换为浮点数类型。

2. 整数或浮点数转字符串：

• 使用 to_string函数可以将整数或浮点数转换为对应的字符串形式。

3. 字符串转字符数组或字符指针：

• 使用 c_str() 可以将 string 类型的字符串转换为以空字符结尾的字符数组（C风格字符串）。
• 使用 data()方法 可以将 string 类型的字符串转换为指向字符串数据的 const char*指针。

函数原型：

//将基本数据类型（如整数、浮点数等）转换为对应的字符串表示。接受一个参数，并返回表示该参数值的字符串。
namespace std {
    string to_string(int val);
    string to_string(unsigned val);
    string to_string(long val);
    string to_string(unsigned long val);
    string to_string(long long val);
    string to_string(unsigned long long val);
    string to_string(float val);
    string to_string(double val);
    string to_string(long double val);
}
// 用于返回一个指向 C 风格字符串的指针，以便与需要 C 风格字符串作为参数的函数交互。
const char* c_str() const noexcept;

代码示例：

void test() {
    std::string str = "12345";
    
    // 字符串转整数
    int num = std::stoi(str);
    long longNum = std::stol(str);
    float floatNum = std::stof(str);
    cout << "Converted integer: " << num << std::endl;
    cout << "Converted long: " << longNum << std::endl;
    cout << "Converted float: " << floatNum << std::endl;

    // 整数转字符串
    int number = 12345;
    string strNum = std::to_string(number);
    cout << "Converted string: " << strNum << std::endl;

    // 字符串转字符数组或字符指针
    const char* charPtr = str.c_str();
    cout << "Character array: " << charPtr << std::endl;
}

三：相关问题的解答

1. const string& str 和 const char* str 的区别

• 类型上：
  const string& str 是一个引用，引用的是 string 类型的对象;
  const char* str 是一个 C 风格的指针，指向以 null 终止的字符数组。
• 功能上：
  const string& str 可以直接接收 string 对象作为参数，方便传递和操作字符串;
  const char* str 需要将字符串以字符数组的形式传递，并需要使用相应的字符串操作函数或者使用字符串字面值进行操作。
• 安全性上：
  const string& str 在传递字符串时会进行类型检查，可以避免空指针引发的错误；
  const char* str 需要确保传入的字符指针有效，并且需要注意空指针的处理。

2. string& str 和 string &s有什么区别

在函数参数中，string& s 和 string &s是完全相同的，它们都表示一个引用类型的参数，引用的是 string 类型的对象。两者的写法只是在空格的使用上稍有差异，但在语义上没有任何区别。

四：总结

以上就是string容器的基本概念和使用方法的全部内容了，具体对容器的基本概念和字符串的构造，赋值，增删修查，比较，拼接，提取子串等操作进行了详细的解析，希望本文可以帮助您更好的使用string容器，重点是进行实操，加深理解！

---

欢迎在评论区留言，期待一起讨论交流！！
欢迎关注🔎点赞👍收藏⭐️留言📝