STL标准模板库之＜string＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：VSCode 1.76.2

string类介绍

string类是basic_string模板类对char类型的特化，封装了常用的字符串操作，如初始化、遍历、查找、拼接、比较、替换等功能。

头文件

#include		 

模块类定义

std::basic_string<char> std::string;

对象构造

//1、无参构造
std::string str1;
//2、等号构造
std::string str2 = "hello world";
//3、char*构造
std::string str3("hello world");
//4、重复字符构造，构造6个a字符
std::string str4(6,'a');
//5、拷贝构造
std::string str5(str2);
//6、移动构造，str4由str6接管
std::string str6(std::move(str4));
//7、指定范围构造,s使用str2的下标为6开始的向后5个字符构造
std::string str7(str2, 6, 5);

容量

函数名	返回值	功能
empty()	布尔值	判断字符串是否为空
size()	字符串大小	获取字符串长度
length()	字符串实际占用长度	获取字符串长度
max_size()	字符串对象最大容量	获取字符串对象最大容量
capacity()	字符串当前容量	获取字符串当前容量，一般比字符串实际长度大
shrink_to_fit()	无	释放字符串对象为使用的空间
reserve()	无	设置字符串保留存储大小

//容量操作
std::string strTest1;
//1、检查字符串是否为空
std::cout << std::boolalpha << strTest1.empty() << std::endl;
//2、获取字符串字节数
strTest1 = "hello world";
std::cout << "size=" << strTest1.size() << ",length=" << strTest1.length() << std::endl;
//3、获取字符串对象的最大容量
std::cout << "max_size=" << strTest1.max_size() << std::endl;
//4、获取字符串最大容量
std::cout << "capacity=" << strTest1.capacity() << std::endl;
//5、释放字符串对象未使用的内存
strTest1.shrink_to_fit();
std::cout << "capacity=" << strTest1.capacity() << std::endl;
//6、设置字符串对象保留长度
strTest1.reserve(100);
std::cout << "capacity=" << strTest1.capacity() << std::endl;

元素访问

函数名	返回值	功能
[]	指定元素的值	访问元素
at()	指定元素的引用	访问元素
front()	首元素的引用	获取首元素
back()	元素的引用	获取末尾元素
data()	首元素的地址	获取指向首元素的指针

/* 使用下标运算符访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout<< arrInt[i] << " ";
}
/* 使用at访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout << arrInt.at(i) << " ";
}
/* 取数组第一个和最后一个元素，返回值类型为元素的引用，注：0长度数组不能使用，运行时后出错 */
std::cout << arrInt.front() << " " << arrInt.back() << std::endl;
/* 获取指向数组头的指针 */
int *p = arrInt.data();

注：front()和back()不能用于获取0长度数组的元素。

字符串比较

函数	返回值	功能
==	bool	判断array是否为空，为空返回true，不为空返回false
compare()	相等时返回0，小于时返回负数，大于时返回正数	比较两个字符串大小
starts_with()	布尔值	判断字符串是否以指定子字符串开头
ends_with()	布尔值	判断字符串是否以指定子字符串结尾

//字符串比较
std::string strCompare1("hello world");
std::string strCompare2("hellO world");
//1、==比较字符串，相等时为true，不等时为false
std::cout << std::boolalpha << (strCompare1 == strCompare2) << std::endl;
//2、compare函数比较,相等返回0,strCompare1小于strCompare2返回负数,反之返回正数
std::cout << strCompare1.compare(strCompare2) << std::endl;
//3、（c++20）比较字符串是否以指定子字符串开头,是则返回true，否则返回false
//std::cout << strCompare1.starts_with("hello") << std::endl;
//4、（c++20）比较字符串是否以指定子字符串结尾,是则返回true,否则返回false
//std::cout << strCompare1.ends_with("txt") << std::endl;

迭代器

类型	功能
iterator	正向随机访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向随机访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向随机访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向随机访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向随机访问迭代器	返回指向string对象首元素所在位置的迭代器
end()	正向随机访问迭代器	返回指向string对象末尾元素的下一个位置的迭代器
cbegin()	常量正向随机访问迭代器	返回指向string对象首元素所在位置的常量迭代器
cend()	常量正向随机访问迭代器	返回指向string对象末尾元素的下一个位置的迭代器
rbegin()	逆向随机访问迭代器	返回指向string对象末尾元素位置的迭代器
rend()	逆向随机访问迭代器	返回指向string对象首元素的前一个位置的迭代器
crbegin()	常量逆向随机访问迭代器	返回指向string对象末尾元素位置的常量迭代器
crend()	常量逆向随机访问迭代器	返回指向string对象首元素的前一个位置的常量迭代器

//迭代器
/*正向随机访问迭代器，每个元素+1*/
std::string strTest2 = "hello world";
std::string::iterator itr;
for (itr = strTest2.begin(); itr != strTest2.end(); itr++)
{
    /* 修改元素值每个字母值+1 */
    *itr += 1; 
    /* 访问元素 */
    std::cout << *itr << " ";
}

/*常量正向随机访问迭代器*/
std::string::const_iterator cItr;
for (cItr = strTest2.cbegin(); cItr != strTest2.cend(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 1; 
    /* 访问元素 */
    std::cout << *cItr << " ";
}

/*逆向随机访问迭代器，每个元素+1*/
std::string strTest3 = "welcome china";
std::string::reverse_iterator rItr;
for (rItr= strTest3.rbegin(); rItr!= strTest3.rend(); rItr++)
{
    /* 修改元素值 */
    *rItr += 1; 
    /* 访问元素 */
    std::cout << *rItr << " ";
}

/*常量逆向随机访问迭代器*/
std::string::const_reverse_iterator crItr;
for (crItr= strTest3.crbegin(); crItr!= strTest3.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout << *crItr << " ";
}

插入和删除

函数	返回值	功能
push_back()	无	字符串末尾插入字符
pop_back()	无	删除字符串末尾字符
append()	字符串引用	字符串末尾追加字符或字符串
insert()	字符串引用	字符串中插入字符或字符串
erase()	字符串引用或迭代器	删除字符串中字符或子字符串
clear()	无	清空字符串中的内容

//插入和删除
std::string strTest4("hello world");
std::string strTest5("hello world!");
//1、在字符串末尾添加字符‘A’
strTest5.push_back('A');
std::cout << strTest5 << std::endl;
//2、删除字符串末尾字符‘A’
strTest5.pop_back();
std::cout << strTest5 << std::endl;
//3、在字符串末尾追加字符或字符串
//3.1、在字符串末尾追加指定数量的指定字符，在末尾追加“ AAAA”
strTest5.append(" ").append(4, 'A');
std::cout << strTest5 << std::endl;
//3.2、在字符串末尾追加整个字符串，在末尾追加“hello world”
strTest5.append(" ").append(strTest4);
std::cout << strTest5 << std::endl;
//3.3、在字符串末尾追加指定长度的char*字符串,末尾追加“appe”
const char *pStr = "append";
strTest5.append(" ").append(pStr, 4);
std::cout << strTest5 << std::endl;
//3.4、在字符串末尾追加另一个字符串指定范围的子字符串,在末尾追加“empstr”
std::string tmpStr("tempstr");
strTest5.append(" ").append(tmpStr.begin() + 1, tmpStr.end());
std::cout << strTest5 << std::endl;
//3.5、通过初始化列表在字符串末尾追加字符串,在末尾追加“init”
strTest5.append(" ").append({'i', 'n','i','t'});
std::cout << strTest5 << std::endl;
//4、在字符串中插入字符或字符串
std::string strTest6("china");
//4.1、在字符串的指定位置插入指定数量个字符，在第一个字符后插入'A'
strTest6.insert(1,1,'A');
std::cout << strTest6 << std::endl;
//4.2、在字符串的指定位插入char*字符串,字符串首部插入“welcome ”
strTest6.insert(0,"welcome ");
std::cout << strTest6 << std::endl;
//4.3、在字符串指定位置插入另一个string字符串,字符串首部插入“ temp  ”
std::string strTemp(" temp ");
strTest6.insert(0, strTemp);
std::cout << strTest6 << std::endl;
//4.4、在迭代器指定的位置插入，另一个字符串的迭代器指定范围的子字符串,在第三个位置后插入“guo”
std::string strTemp1("zhongguo");
strTest6.insert(strTest6.begin()+3, strTemp1.begin()+5, strTemp1.end());
std::cout << strTest6 << std::endl;
//4.5、在指定位置通过初始化列表插入字符串, 字符串首部插入“ABC”
strTest6.insert(0, {'A','B','C'});
std::cout << strTest6 << std::endl;
//5、删除字符串中的指定字符或字符串
//5.1、删除指定位置开始的指定数量个字符，删除字符串首部“ABC”
strTest6.erase(0, 3);
std::cout << strTest6 << std::endl;
//5.2、删除迭代器指定位置的字符, 删除字符串首字符‘ ’
strTest6.erase(strTest6.begin());
std::cout << strTest6 << std::endl;
//5.3、删除迭代器指定范围内的字符，删除字符串第二个位置到第5个位置的字符
strTest6.erase(strTest6.begin()+1, strTest6.begin()+5);
std::cout << strTest6 << std::endl;
//6、清空字符串中的内容
strTest6.clear();
std::cout << strTest6 << std::endl;

替换和子字符串

函数	返回值	功能
replace()	字符串引用	替换字符或子字符串
substr()	子字符串对象	获取子字符串

//字符串替换和子字符串
std::string strTest7("hello this is an example");
//1、字符或子字符串替换
//1.1、将指定位置的开始的指定个数的字符串替换为新的字符串,将this替换为“ABC”
strTest7.replace(6,4, std::string("ABC"));
std::cout << strTest7 << std::endl;
//1.2、将迭代器指定范围内的字符串替换为新的字符串
strTest7.replace(strTest7.begin()+6, strTest7.begin()+9, "this");
std::cout << strTest7 << std::endl;
//1.3、将指定位置的固定数量个字符替换为指定数量个相同新字符
strTest7.replace(6, 4, 5, 'X');
std::cout << strTest7 << std::endl;
//1.4、将迭代器指定范围的字符串替换为迭代器指定范围的新字符
std::string strTemp2("this");
strTest7.replace(strTest7.begin()+6, strTest7.begin()+11, strTemp2.begin(), strTemp2.end());
std::cout << strTest7 << std::endl;
//1.5、将迭代器指定范围的字符替换为初始化列表构造的字符串
strTest7.replace(strTest7.begin()+6, strTest7.begin()+10, {'T', 'H', 'I', 'S'});
std::cout << strTest7 << std::endl;
//2、子字符串
//2.1、获取字符串指定位置的指定数量的子字符串
std::cout << strTest7.substr(6, 4) << std::endl;
std::cout << strTest7.substr(6, 30) << std::endl;

字符串查找

函数	返回值	功能
find()	字符串索引值	正向查找目标字符串或字符在原字符串中的位置
rfind()	字符串索引值	反向查找目标字符串或字符在原字符串中的位置
find_first_of()	字符索引值	正向查找目标字符串中字符在原字符串中首次出现的位置
find_last_of()	字符索引值	反向查找目标字符串中字符在原字符串中首次出现的位置
find_first_not_of()	字符索引值	正向查找不在目标字符串中的字符在原字符串中首次出现的位置
find_last_not_of()	字符索引值	反向查找不在目标字符串中的字符在原字符串中首次出现的位置

注意：字符串查找时如果没有找到目标字符串，那么会返回std::string::npos值，可以使用此值判断是否有找到目标字符串或字符。

//字符串查找
std::string strTest8("this is an example!");
//1、从前向后查找目标字符串在原字符串中的位置
//1.1、从首字符开始查找子字符串
std::cout << strTest8.find("an") << std::endl;
//1.2、从指定位置开始查找子字符串
std::cout << strTest8.find("an", 4) << std::endl;
//1.3、从指定位置开始查找目标字符串指定长度的子字符串
std::cout << strTest8.find("xamp", 4, 3) << std::endl;
std::cout << strTest8.find("ex", 4, 2) << std::endl; 
//1.4、从首字符开始查找单个字符
std::cout << strTest8.find('h') << std::endl;
//1.5、从指定位置开始查找单个字符
std::cout << strTest8.find('p',10) << std::endl;
//2、从后向前查找目标字符串在原字符串中的位置
//2.1、从末尾字符开始反向查找子字符串
std::cout << strTest8.rfind("an") << std::endl;
//2.2、从指定位置开始查找子字符串
std::cout << strTest8.rfind("an", strTest8.length()-8) << std::endl;
//2.3、从指定位置开始反向查找指定数量个字符
std::cout << strTest8.rfind("ex", strTest8.length()-2, 2) << std::endl;
std::cout << strTest8.rfind("ex", strTest8.length()-8, 2) << std::endl; 
//2.4、从末尾字符开始查找单个字符
std::cout << strTest8.rfind('h') << std::endl;
//2.5、从指定位置开始查找单个字符
std::cout << strTest8.rfind('p',strTest8.length()-2) << std::endl;
//3、从前向后查找目标字符串中包含字符在原字符串中的位置
//3.1、从首字符开始查找
std::cout << strTest8.find_first_of("mx") << std::endl;
//3.2、从指定位置开始查找
std::cout << strTest8.find_first_of("mx", 4) << std::endl;
//3.3、从指定位置查找指定数量个字符
std::cout << strTest8.find_first_of("xe", 8, 10) << std::endl;
//3.4、从首字符开始查找单个字符
std::cout << strTest8.find_first_of('m') << std::endl;
//3.5、从指定位置开始查找单个字符
std::cout << strTest8.find_first_of('e', 8) << std::endl; 
//4、从后向前查找目标字符串中包含字符在原字符串中的位置
//4.1、从尾字符反向查找
std::cout << strTest8.find_last_of("mx") << std::endl;
//4.2、从指定位置开始反向查找
std::cout << strTest8.find_last_of("mx", 4) << std::endl;
//4.3、从指定位置反向查找指定数量个字符
std::cout << strTest8.find_last_of("xe", 8, 10) << std::endl;
//4.4、从尾字符开始反向查找单个字符
std::cout << strTest8.find_last_of('m') << std::endl;
//4.5、从指定位置开始反向查找单个字符
std::cout << strTest8.find_last_of('e', 8) << std::endl; 
//5、从前向后查找目标字符串中不包含的字符在原字符串中的位置
//5.1、从首字符开始查找
std::cout << strTest8.find_first_not_of("this") << std::endl;
//5.2、从指定位置开始查找
std::cout << strTest8.find_first_not_of("this", 4) << std::endl;
//5.3、从指定位置查找指定数量个字符
std::cout << strTest8.find_first_not_of("th", 8, 10) << std::endl;
//5.4、从首字符开始查找单个字符
std::cout << strTest8.find_first_not_of('t') << std::endl;
//5.5、从指定位置开始查找单个字符
std::cout << strTest8.find_first_not_of('t', 8) << std::endl; 
//6、从后向前查找目标字符串中不包含的字符在原字符串中的位置
//6.1、从尾字符反向查找
std::cout << strTest8.find_last_not_of("!elp") << std::endl;
//6.2、从指定位置开始反向查找
std::cout << strTest8.find_last_not_of("!elp", 4) << std::endl;
//6.3、从指定位置反向查找指定数量个字符
std::cout << strTest8.find_last_not_of("xe", 8, 10) << std::endl;
//6.4、从尾字符开始反向查找单个字符
std::cout << strTest8.find_last_not_of('m') << std::endl;
//6.5、从指定位置开始反向查找单个字符
std::cout << strTest8.find_last_not_of('e', 8) << std::endl; 

数值转字符串

函数	返回值	功能
to_string()	字符串对象	数值转字符串

//数值转字符串
//1、int、long、long long、 转字符串
std::cout << std::to_string(65535) << std::endl;
//2、float、double转字符串
std::cout << std::to_string(3.1415926) << std::endl;

字符串转数值

函数	返回值	功能
stoi()	有符合int值	字符串转有符合int
stol()	有符合long值	字符串转有符合long
stoll()	有符号long long值	字符串转有符合long long
stoul()	无符号long值	字符串转无符号long
stoull()	无符号long long值	字符串转无符号long long
stof()	float值	字符串转float
stod()	double值	字符串转double
stold()	long double值	字符串转long double

//字符串转数值
//1、字符串转int、long、long long等
std::cout << std::stoi(std::string("65535")) << std::endl;
std::cout << std::stol(std::string("12345678")) << std::endl;
std::cout << std::stoll(std::string("123456789987654321")) << std::endl;
//2、字符串转float、double
std::cout << std::stof(std::string("3.1415")) << std::endl;
std::cout << std::stod(std::string("2.5e12")) << std::endl;

STL库还提供了string_view类，可以使用string_view类来代替string类，从而提高字符串各种操作的性能。