浅谈C++|STL之string篇

举报
白茶加冰 发表于 2023/09/13 23:13:24 2023/09/13
【摘要】 一.string的基本概念本质string是C++风格的字符串,而string本质是一个字符串string和char * 区别char * 是一个指针string是一个类,类内部封装了char *,管理这个字符串,是一个char * 型容器。特点string类内部封装了很多成员方法例如:查找find,拷贝copy,删除delete替换replace,插入insertstring管理char...

image.png

一.string的基本概念

本质

string是C++风格的字符串,而string本质是一个字符串

string和char * 区别

  • char * 是一个指针
  • string是一个类,类内部封装了char *,管理这个字符串,是一个char * 型容器。

特点

string类内部封装了很多成员方法

例如:查找find,拷贝copy,删除delete替换replace,插入insert
string管理char*所分配的内存,不用担心复制越界和取值越界等,由类内部进行负责

二.string构造函数

以下是std::string的构造函数原型整理成表格的形式:

构造函数 描述
string() 默认构造函数
string(const char* s) 使用C风格字符串构造函数
string(const char* s, size_t n) 使用C风格字符串和长度构造函数
string(size_t n, char c) 使用重复字符构造函数
string(const string& str) 拷贝构造函数
string(string&& str) noexcept 移动构造函数
template <class InputIterator> string(InputIterator first, InputIterator last) 使用迭代器范围构造函数
string(initializer_list<char> ilist) 使用初始化列表构造函数
#include <iostream>
#include <string>
using namespace std;
int main() {
	//默认构造函数
	string str1;
	string str2("使用C风格字符串构造函数");
	string str3("使用C风格字符串和长度构造函数", 5);
	string str4(10, 'a');
	string str = "拷贝构造函数";
	string str5(str);
	string&& str6 = move("移动构造函数");
	str = "使用迭代器范围构造函数";
	string str7(str.begin(), str.end());
	string str8[2] = { "使用初始化", "列表构造函数" };
	cout << "wetr";
	cout << str1 << endl;
	cout << str2 << endl;
	cout << str3 << endl;
	cout << str4 << endl;
	cout << str5 << endl;
	cout << str6 << endl;
	cout << str7 << endl;
	cout << str8[1]<< str8[2] << endl;
	return 0;
}

![2023-09-01T01:46:05.png][1]

二.string的赋值操作

以下是std::string的赋值操作函数原型整理成表格的形式:

函数原型 描述
string& operator=(const string& str) 赋值运算符重载:从另一个字符串赋值
string& operator=(string&& str) noexcept 赋值运算符重载:移动赋值
string& operator=(const char* s) 赋值运算符重载:从C风格字符串赋值
string& operator=(char c) 赋值运算符重载:从单个字符赋值
string& operator=(initializer_list<char> ilist) 赋值运算符重载:从初始化列表赋值
string& assign(const string& str) 成员函数:从另一个字符串赋值
string& assign(string&& str) noexcept 成员函数:移动赋值
string& assign(const char* s) 成员函数:从C风格字符串赋值
string& assign(const char* s, size_t n) 成员函数:从C风格字符串和长度赋值
string& assign(size_t n, char c) 成员函数:使用重复字符赋值
string& assign(initializer_list<char> ilist) 成员函数:从初始化列表赋值
string& assign(const_iterator first, const_iterator last) 成员函数:使用迭代器范围赋值
#include <iostream>
#include <string>
using namespace std;
int main() {
	string str1;
	str1 = "从另一个字符串赋值";
	cout << str1 << endl;
	str1 = move("移动赋值");
	cout << str1 << endl;
	str1 = "从C风格字符串赋值";
	cout << str1 << endl;
	string str = "  使用迭代器范围赋值";
	str1.assign(str.begin()+2, str.end());
	cout << str1 << endl;
	return 0;
}

![2023-09-01T02:02:34.png][2]

三.string拼接操作

以下是std::string的字符串拼接操作函数原型整理成表格的形式:

函数原型 描述
string operator+(const string& lhs, const string& rhs) 运算符重载:字符串与字符串的拼接
string operator+(const string& lhs, const char* rhs) 运算符重载:字符串与C风格字符串的拼接
string operator+(const char* lhs, const string& rhs) 运算符重载:C风格字符串与字符串的拼接
string operator+(const string& lhs, char rhs) 运算符重载:字符串与单个字符的拼接
string operator+(char lhs, const string& rhs) 运算符重载:单个字符与字符串的拼接
string& append(const string& str) 成员函数:追加拼接另一个字符串
string& append(const string& str, size_t subpos, size_t sublen) 成员函数:从另一个字符串的指定位置截取指定长度后进行拼接
string& append(const char* s) 成员函数:追加拼接C风格字符串
string& append(const char* s, size_t n) 成员函数:追加拼接C风格字符串的指定长度
string& append(size_t n, char c) 成员函数:追加拼接指定数量的重复字符
string& append(initializer_list<char> ilist) 成员函数:追加拼接初始化列表中的字符
#include <iostream>
#include <string>
using namespace std;
int main() {
	string str;
	string str1 = "01234567";
	str += "hello";
	str += string("word");
	str += (string("  word") + "20  ");
	str.append(str1, 5, 2);
	cout << str;
	return 0;
}

四.string的查找和替换

下面是关于std::string查找和替换的常用函数原型:

查找相关函数:

函数原型 描述
size_t find(const string& str, size_t pos = 0) const noexcept; 在字符串中查找另一个字符串的位置
size_t find(const char* s, size_t pos = 0) const; 在字符串中查找C风格字符串的位置
size_t find(char c, size_t pos = 0) const noexcept; 在字符串中查找字符的位置
size_t rfind(const string& str, size_t pos = npos) const noexcept; 在字符串中从后往前查找另一个字符串的位置
size_t rfind(const char* s, size_t pos = npos) const; 在字符串中从后往前查找C风格字符串的位置
size_t rfind(char c, size_t pos = npos) const noexcept; 在字符串中从后往前查找字符的位置
size_t find_first_of(const string& str, size_t pos = 0) const noexcept; 在字符串中查找第一个匹配另一个字符串中任意字符的位置
size_t find_first_of(const char* s, size_t pos = 0) const; 在字符串中查找第一个匹配C风格字符串中任意字符的位置
size_t find_first_of(char c, size_t pos = 0) const noexcept; 在字符串中查找第一个匹配字符的位置
size_t find_last_of(const string& str, size_t pos = npos) const noexcept; 在字符串中从后往前查找第一个匹配另一个字符串中任意字符的位置
size_t find_last_of(const char* s, size_t pos = npos) const; 在字符串中从后往前查找第一个匹配C风格字符串中任意字符的位置
size_t find_last_of(char c, size_t pos = npos) const noexcept; 在字符串中从后往前查找第一个匹配字符的位置
size_t find_first_not_of(const string& str, size_t pos = 0) const noexcept; 在字符串中查找第一个不匹配另一个字符串中任意字符的位置
size_t find_first_not_of(const char* s, size_t pos = 0) const; 在字符串中查找第一个不匹配C风格字符串中任意字符的位置
size_t find_first_not_of(char c, size_t pos = 0) const noexcept; 在字符串中查找第一个不匹配字符的位置
size_t find_last_not_of(const string& str, size_t pos = npos) const noexcept; 在字符串中从后往前查找第一个不匹配另一个字符串中任意字符的位置
size_t find_last_not_of(const char* s, size_t pos = npos) const; 在字符串中从后往前查找第一个不匹配C风格字符串中任意字符的位置
size_t find_last_not_of(char c, size_t pos = npos) const noexcept; 在字符串中从后往前查找第一个不匹配字符的位置

替换相关函数:

函数原型 描述
string& replace(size_t pos, size_t len, const string& str); 替换指定位置和长度的子字符串为另一个字符串
string& replace(size_t pos, size_t len, const char* s); 替换指定位置和长度的子字符串为C风格字符串
string& replace(size_t pos, size_t len, const char* s, size_t n); 替换指定位置和长度的子字符串为C风格字符串的指定长度
string& replace(size_t pos, size_t len, size_t n, char c); 替换指定位置和长度的子字符串为指定数量的重复字符
string& replace(iterator first, iterator last, const string& str); 替换迭代器范围内的子字符串为另一个字符串
string& replace(iterator first, iterator last, const char* s); 替换迭代器范围内的子字符串为C风格字符串
string& replace(iterator first, iterator last, const char* s, size_t n); 替换迭代器范围内的子字符串为C风格字符串的指定长度
string& replace(iterator first, iterator last, size_t n, char c); 替换迭代器范围内的子字符串为指定数量的重复字符
#include <iostream>
#include <string>
using namespace std;
int main() {
	string str = "1234578912345789";
	int a = str.find("78");
	cout << a << endl;
	a = str.rfind("78");
	cout << a << endl;
	//从下标1开始的三个字符替换成abcd
	str.replace(1, 3, "abcd");
	cout << str << endl;
	return 0;
}

![2023-09-01T02:19:00.png][3]

五.string的字符串比较

下面是关于std::string比较的常用函数原型:

函数原型 描述
int compare(const string& str) const noexcept; 比较字符串和另一个字符串
int compare(size_t pos, size_t len, const string& str) const; 比较字符串的子串和另一个字符串
int compare(const char* s) const; 比较字符串和C风格字符串
int compare(size_t pos, size_t len, const char* s) const; 比较字符串的子串和C风格字符串
int compare(size_t pos, size_t len, const char* s, size_t n) const; 比较字符串的子串和指定长度的C风格字符串

上述函数通过返回整数值来表示比较的结果,其返回值的含义如下:

  • 返回值 < 0 表示当前字符串小于目标字符串。

  • 返回值 > 0 表示当前字符串大于目标字符串。

  • 返回值 = 0 表示当前字符串等于目标字符串。

    #include <iostream>
    #include <string>
    using namespace std;
    int main() {
    string str = “1234578912345789”;
    //从0下标开始的6个字符的子串,后一个的字串比较
    int m=str.compare(0,6, “12345789”, 6);
    cout << m << endl;
    return 0;
    }

六.string字符串存取

下面是关于std::string字符串存取的常用函数原型:

函数原型 描述
char& operator[](size_t pos); 访问字符串中指定位置的字符
const char& operator[](size_t pos) const; 访问字符串中指定位置的字符(const版本)
char& at(size_t pos); 访问字符串中指定位置的字符,带范围检查
const char& at(size_t pos) const; 访问字符串中指定位置的字符,带范围检查(const版本)
char& front(); 访问字符串的第一个字符
const char& front() const; 访问字符串的第一个字符(const版本)
char& back(); 访问字符串的最后一个字符
const char& back() const; 访问字符串的最后一个字符(const版本)
const char* data() const noexcept; 返回字符串数据的指针
const char* c_str() const noexcept; 返回以空字符结尾的字符串的指针(C风格字符串)
const char* data() const noexcept; 返回字符串数据的指针
const char* c_str() const noexcept; 返回以空字符结尾的字符串的指针(C风格字符串)

这些函数允许您对std::string对象进行字符的存取操作,可以直接访问特定位置的字符,或者获取字符串的首尾字符。data()c_str()函数还可以返回字符串数据的指针(以及以空字符结尾的C风格字符串的指针),方便与C语言接口进行交互操作。请注意,在只读的场景下使用at()函数可以提供范围检查,避免越界访问。

七.string的插入和删除

下面是关于std::string插入和删除字符串的常用函数原型:

函数原型 描述
string& insert(size_t pos, const string& str); 在指定位置插入另一个字符串
string& insert(size_t pos, const string& str, size_t subpos, size_t sublen); 在指定位置插入另一个字符串的子串
string& insert(size_t pos, const char* s); 在指定位置插入C风格字符串
string& insert(size_t pos, const char* s, size_t n); 在指定位置插入指定长度的C风格字符串
string& insert(size_t pos, size_t n, char c); 在指定位置插入指定数量的字符
iterator insert(iterator p, char c); 在指定位置插入单个字符
iterator insert(iterator p, size_t n, char c); 在指定位置插入指定数量的字符
iterator insert(iterator p, InputIt first, InputIt last); 在指定位置插入迭代器范围的字符
template <class InputIt> void insert(iterator p, InputIt first, InputIt last); 在指定位置插入迭代器范围的字符
template <class InputIt> void insert(iterator p, initializer_list<typename InputIt::value_type> ilist); 在指定位置插入初始化列表的字符
string& erase(size_t pos = 0, size_t len = npos); 删除字符串的子串
iterator erase(iterator p); 删除指定位置的字符
iterator erase(iterator first, iterator last); 删除迭代器范围内的字符

这些插入和删除函数允许您在std::string对象中插入或删除字符串内容。通过这些函数,您可以在指定位置插入字符串、字符或字符范围,也可以删除字符串子串、指定位置的字符或一段字符范围。这些函数提供了灵活的方式来操作字符串,满足不同场景下的需求。

八.获得string的子串

以下是使用substr函数获取字符串子串的表格总结:

函数原型 描述
string substr(size_t pos = 0, size_t len = npos) const; 获取从指定位置开始的一段子串

示例:

std::string str = "Hello, World!";
std::string sub1 = str.substr(7);        // "World!"
std::string sub2 = str.substr(0, 5);     // "Hello"
std::string sub3 = str.substr(7, 5);     // "World"

使用substr函数,您可以方便地获得std::string的子串,通过指定起始位置和长度参数来进行操作。

九.函数接口

序号 函数接口 功能描述
1 push_back© 在字符串的末尾添加字符 c
2 pop_back() 删除字符串的最后一个字符
3 resize(n) 调整字符串的大小为 n
4 resize(n, c) 调整字符串的大小为 n,并将新增的元素初始化为字符 c
5 front() 返回字符串的第一个字符
6 back() 返回字符串的最后一个字符
7 find_first_of(str) 在字符串中查找字符串 str 中的任意字符第一次出现的位置
8 find_first_not_of(str) 在字符串中查找字符串 str 中的任意字符第一次不出现的位置
9 find_last_of(str) 在字符串中从后往前查找字符串 str 中的任意字符最后一次出现的位置
10 find_last_not_of(str) 在字符串中从后往前查找字符串 str 中的任意字符最后一次不出现的位置
11 toLowerCase() 将字符串中的字母全部转换为小写
12 toUpperCase() 将字符串中的字母全部转换为大写
13 at(n) 返回字符串中索引为 n 的字符
14 operator[] (n) 返回字符串中索引为 n 的字符
15 substr(pos) 返回从位置 pos 开始到字符串末尾的子字符串
16 compare(pos, len, str) 将字符串中从位置 pos 开始的长度为 len 的子字符串与字符串 str 比较
17 getline(input_stream, str, delimiter) 从输入流 input_stream 中读取一行文本,并将结果存储到字符串 str 中
18 stoi(str) 将字符串 str 转换为整数值
19 stol(str) 将字符串 str 转换为长整数值
20 stof(str) 将字符串 str 转换为浮点数值
21 to_string(value) 将值 value 转换为字符串
22 find_last_of(str, pos) 在字符串中从位置 pos 开始从后往前查找字符串 str 第一次出现的位置
23 find_last_not_of(str, pos) 在字符串中从位置 pos 开始从后往前查找字符串 str 第一次不出现的位置
24 replace(pos, len, newstr, newlen) 将字符串中从位置 pos 开始的长度为 len 的子字符串替换为新的字符串
25 find_first_of(str, pos) 在字符串中从位置 pos 开始查找字符串 str 中的任意字符第一次出现的位置
26 find_first_not_of(str, pos) 在字符串中从位置 pos 开始查找字符串 str 中的任意字符第一次不出现的位置
27 compare(pos, len, str, subpos, sublen) 将字符串中从位置 pos 开始的长度为 len 的子字符串与字符串 str 中从位置 subpos 开始的长度为 sublen 的子字符串进行比较
28 replace(pos, len, str) 将字符串中从位置 pos 开始的长度为 len 的子字符串替换为字符串 str
29 capacity() 返回字符串当前能够容纳的字符数
30 reserve(n) 将字符串的容量设置为至少为 n 个字符
31 shrink_to_fit() 将字符串的容量调整为与字符串的长度相匹配,以节省内存空间
32 find_last_of(str, pos) 在字符串中从位置 pos 开始从后往前查找字符串 str 中的任意字符最后一次出现的位置
33 find_last_not_of(str, pos) 在字符串中从位置 pos 开始从后往前查找字符串 str 中的任意字符最后一次不出现的位置
34 replace(pos, len, newstr) 将字符串中从位置 pos 开始的长度为 len 的子字符串替换为新的字符串
35 replace(iterator1, iterator2, newstr) 将迭代器 iterator1 和 iterator2 之间的子字符串替换为新的字符串
36 copy(char_array, len, pos) 将字符串中从位置 pos 开始的长度为 len 的子字符串复制到字符数组 char_array 中
37 find_if(predicate) 在字符串中查找满足谓词函数 predicate 的第一个字符的位置
38 rfind(str) 在字符串中从后往前查找子字符串 str 并返回第一次出现的位置
39 rfind(str, pos) 在字符串中从位置 pos 开始从后往前查找子字符串 str 并返回第一次出现的位置
40 replace_if(predicate, newstr) 将字符串中满足谓词函数 predicate 的字符替换为新的字符串

请注意,这里的表格仅提供了功能描述的简要介绍,具体的函数行为和参数要求请查阅官方文档以获取详细信息。

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。