【C++】STL —— String类不会怎么办? 看文档(万字详解)
🌈欢迎来到C++专栏~~String类(万字详解)
- (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort🎓
- 🌍博客主页:张小姐的猫~江湖背景
- 快上车🚘,握好方向盘跟我有一起打天下嘞!
- 送给自己的一句鸡汤🤔:
- 🔥真正的大师永远怀着一颗学徒的心
- 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏
- 🎉🎉欢迎持续关注!
本文目标
- 🌈欢迎来到C++专栏~~String类(万字详解)
- 一. 编码科普
- 🐋ASCII码
- 🐋Unicode
- 🐋gbk
- 二. String类
- 三.构造 & 析构 & 赋值重载
- ⚡构造函数
- ⚡析构函数(不重要)
- ⚡赋值重载
- 四.operator[ ]
- 五、Capacity 容量操作
- ⚡size vs length
- capacity
- ⚡resize vs reverse
- ⚡clear
- ⚡empty
- 六、iterator 迭代器
- 🌈正向迭代器
- 🌈反向迭代器
- 🌈const迭代器
- 🌈范围for遍历
- 七、Modifiers 修改
- 🎨追加
- 🎨插入和删除
- 八、String operations 字符串操作
- 🌍substr 子串
- 🌍查找 find & rfind
- 💢find 和find_first_of 区别
- 九、非成员函数重载
- 💦流插入&流提取
- 💦getline
- 💦to_string
- 十、 vs和g++下string结构的说明(了解)
- 📢写在最后
学习STL要多翻阅官方文档 cplusplus.com,话不多说,发车
一. 编码科普
为什么string不能针对char来写?因为编码不同。char只能表示256个字符。
所以这时候要用模板。
string管理的是一个char*的字符串。
u16string:一个字符是两个字节
u32string:一个字符是四个字节
wstring:叫做宽字符,一个字符占两个字节
🐋ASCII码
ASCII码表。是美国设计的。
ASCII码表是:计算机当中存的值,和字符的映射
但是只有256个字符的表示。用char表示
🐋Unicode
也叫做万国码。
Unicode是针对全世界的语言而设计的一种编码。
常见的有utf-8 utf-16 utf-32
🐋gbk
gbk是叫做国标码。是针对中文创建的一个编码。其中还涉及台湾的繁体字。
计算机上不止有英文,还要有中文,日文等语言。但是ASCII码表不足以表示
二. String类
string类实际上是basic_string
这个类模板的实例化 ——
其底层实现大概如下:
template<class T>
class basic_string
{
// ...
private:
T* _str; //动态申请的
size_t _size;
size_t _capacity;
// ...
};
我们发现字符串类型不仅仅只有字符串,为什么还会有类模板呢?这就涉及到不同编码规则问题
在ascii编码表(老美写的)中,将值和符号建立映射关系,1byte
空间可以表示256
个英文字符;再说unicode,是为了表示全世界文字的编码表,其中的utf-16方案,所有字符,无论中英还是啥,都是两字节表示。我们认识到的,字符可不简单的是char,还可以是wchar宽字符等等
🔥下面介绍string类常用的接口 ,要熟练掌握,其余的用时查阅即可。在使用string类时,需要包含头文件#include<string>
以及展开命名空间using namespace std;
三.构造 & 析构 & 赋值重载
⚡构造函数
展示:——
这里我们看见是一个空串,但是为了更好的兼容c,它后面是给了一个\0
的,我在原始视图里发现
说明符合c字符串的规范
其余的接口简单演示,主要为了演示如何查阅文档
⚡ 功能:从pos开始取对象的一部分(len)。
substring (3) string (const string& str, size_t pos, size_t len = npos);
其中len给了缺省值npos
,npos是string类的一个静态成员变量,值为-1
,换算成补码就是全1,赋值给了size_t,也就是整型的最大值4,294,967,295。那如果不传参数的话,基本上是有多少取多少。
注:string类对象支持直接用cin和cout进行输入和输出,因为重载了流插入>>和流提取<<操作符(后面说)
⚡取字符串前n个(用的非常少)
from sequence (5) string (const char* s, size_t n);
⚡ 一键初始化
fill (6) string (size_t n, char c);
⚡析构函数(不重要)
析构我们不管,对象出了作用域,自动调用的
⚡赋值重载
string s1;
string s2 = "hello world";//构造+拷贝构造-》优化——直接构造
s1 = s2;
s1 = "xxxxx";
s1 = 'y';
如果现在让我们取实现逆置一个字符串,我们又不能拿的到str(私有),何况我们都不知道底层是_str 还是str_ ,不清楚底层实现,这就要引出[]
四.operator[ ]
重载了[]
,使得string类可以像数组一样访问字符。不同的是,数组访问本质是解引用,而这里是调用函数。
它提供了两个版本 ——
其大概的底层实现如下:
char& operator[](size_t pos)//传引用返回,别名
{
assert(pos<_size);
return _str[pos];
}
operator[]
是传引用返回,返回的是别名,这使得它可读可写。
这里不是为了减少拷贝,而是为了做输出型参数,支持修改返回值
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s("more than words");
// 1.可读
//for (size_t i = 0; i < s.length(); i++) 二者都是求长度,string比较早,且不适合一些树的结构
for (size_t i = 0; i < s.size(); i++)
{
//等价于cout << s.operator[](i) << " " <<;
cout << s[i] << ' ' ;
}
cout << endl;
// 2.可写
for (size_t i = 0; i < s.size(); i++)
{
s[i] += 1;
}
cout << s << endl;
return 0;
}
对于const修饰的就不能修改了
const string s2("hello world");
for (size_t i = 0; i < s1.size(); ++i)
{
s2[i]++;//报错了
}
下面两个函数功能一致,(at的存在有历史原因)只不过二者检查越界的方式不同,推荐使用[]
——
五、Capacity 容量操作
⚡size vs length
➰字符串中有效字符长度,即不包含最后作为结尾标识符的\0
两者底层实现完全一致(length的存在是历史原因),但强烈推荐使用size
. 这是为了和后序各种容器接口保持一致(二叉树你不能用length吧)
capacity
➰ 容量:能存多少个有效字符(注意\0无效字符不算),要记得string类的底层是顺序表结构,初始值是15
⚡resize vs reverse
➰reserve 和 resize 都是改变容量,申请至少n个字符的空间(字符串涉及对齐问题,后续详谈) ,但有所不同 ——
🤞1. resize
- 开空间,并可以对空间初始化
翻译知道
- 如果是将元素个数减少,会把多出
size
的字符抹去,这不挺resize的吗(狗头) - 如果是将元素个数增多,
void resize (size_t n);
,用\0
来填充多出的元素空间,void resize (size_t n, char c);
用字符c
来填充多出的元素空间 - 注:resize在改变元素个数时,如果是将元素个数增多,可能会改变容量的大小;如果是将元素个数size减少,容量不变
void test_string14()
{
string s1("JDG 总冠军");
s1.resize(5);//size缩小成5,capacity不变
string s2("JDG 总冠军");
s2.resize(100);//填充'\0',size——>100,capacity->111(自动扩容)
string s3("JDG 总冠军");
s3.resize(100,'~');//填充'\0',size——>100,capacity->111(自动扩容)
}
➰ 2. reserve - 开空间。在已知需要多少空间时,调用reserve,可以避免频繁增容的消耗
- 为字符串预留空间,改变容量。当然了不会改变有效元素个数size
- 给reserve的参数n小于string的容量时,是无效请求,并不会改变容量大小
#include<string>
using namespace std;
int main()
{
string s1;
s1.reserve(100); // size - 0,capcacity->111
string s2("more than words");
s2.reserve(5); // capacity和size仍为15
return 0;
}
⚡clear
➰ 清空有效字符,容量不变
⚡empty
➰ 检测字符串是否为空串
六、iterator 迭代器
第二种遍历的方法:迭代器,对于string类,无论正着还是倒着走,[下标]
的方法都足够好用,为什么还要有迭代器?
🤞🤞事实上,迭代器是一种通用的遍历方式,且用法类似,所有容器都可以使用迭代器这种方式去访问修改,而list、map/set不支持[下标]遍历。结论是,对于string类,我们得会用迭代器,但是我们更喜欢用[下标]
🌈正向迭代器
正向迭代器提供了两个函数——
🌈迭代器 iterator是像指针一样的类型,不确定是不是(薛定谔的猫),但它的用法像指针一样, 其区间[ }
左闭右开
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s("more than words");
// 1.可读
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
// 2.可写
it = s.begin();
while (it != s.end())
{
*it += 1;
it++;
}
cout << s <<endl;
return 0;
}
- iterator依然提供了两个版本,第二个是const变量
- 关于遍历的时候
!=
能不能改成<=
,可以但是没必要,因为在string的物理空间是连续的,其他容器list等不一定连续。
🌈反向迭代器
也提供了两个成员函数
void test_string5()
{
string s("hello");
string::reverse_iterator rit = s.rbegin();
//auto rit = s.rbegin();//auto 可以自动推导类型
while (rit != s.rend())
{
cout << *rit << " ";
rit++;
}
cout << endl;
}
🌈const迭代器
所谓的const迭代器就是针对const的版本嘛
- 普通迭代器可读可写,相当于string类模板中,类型为
T*
- 而const迭代器不可写。这是因为是const成员函数,const修饰this指针指向的内容(相当于string类模板中,类型为
const T*
)
const迭代器也分正向迭代器和反向迭代器,且就是给const对象用
的。这是因为const对象才能调用这里的const成员函数,返回const迭代器,不可写。
使用情况如下:
void test_string6()
{
string s("hello");
// const正向迭代器 - 可读不可写
string::const_iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
// const反向迭代器 - 可读不可写
string::const_reverse_iterator rit = s.rbegin();
while (rit != s.rend())
{
cout << *rit << " ";
rit++;
}
cout << endl;
}
传参进func中,s是const对象,自动调用第二个接口,返回的是const_iterator,要用const迭代器类型接收,且不能修改
C++11
为了区分const迭代器和普通迭代器还提供了以下接口,不然调用时容易混淆
🌈范围for遍历
范围for是C++11提供的语法糖🍬,实际上底层编译器会替换成迭代器(反汇编里可以看出) 只能正向遍历
🍬依次取s
中的每个字符,赋值给ch
- 自动迭代
- 自动判断结束
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s("more than words");
for (auto& ch : s)
{
cout << ch << " ";
}
cout << endl;
for (auto& ch : s)
{
ch += 1;
}
cout << s << endl;
return 0;
}
ps:
- 若要修改,auto要加上&。因为
*it
会依次赋值给ch
,ch是*it的拷贝,*it改变不影响ch,所以要加上&
七、Modifiers 修改
🎨追加
+=
最好用也最常用,因为既可以追加字符、也可追加字符串 ,其实底层调用了append
和push_back
void test_string7()
{
string s("hello");
s.push_back('-');
s.push_back('-');
s.append("world");
cout << s << endl;
string str("我来了");
s += '@';//字符
s += str;//字符串
s += "JDG总冠军";
cout << s << endl;
}
其中append的迭代器可以选择性的打印字符串内容(了解即可)
string s("hello");
string str("我来了");
s.append(++str.begin(), --str.end());
string copy(s.begin() + 5, s.end() -5);
下面来研究尾插扩容容量变化 ——
void test_string8()
{
string s;
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
我们可以看见在vs下增容,第一次是两倍,后面是1.5倍的增容
如果提前知道是多少空间,可以调用reserve
预留空间,避免频繁增容的消耗
s.resize(1000 , 'x'); //开空间+初始化
🎨插入和删除
🐋尽量少使用头部的插入和删除,因为要挪动,O(N)效率低
🤞1️⃣小练习:在字符串中空格的地方插入一个%
我的第一想法:遍历字符串,遇到' '
的时候,直接插入
void test_string9()
{
//在空格的地方插入一个%
string str("JDG NB 总冠军");
for (size_t i = 0; i < str.size(); ++i)
{
if (str[i] == ' ')
{
str.insert(i, "20%");
}
}
cout << str << endl;
}
但这样有没有问题呢?
那怎么样处理比较好呢?只需要在插入的地方i
额外的+3
,
void test_string9()
{
//在空格的地方插入一个%
string str("JDG NB 总冠军");
for (size_t i = 0; i < str.size(); ++i)
{
if (str[i] == ' ')
{
str.insert(i, "20%");
i += 3;
}
}
cout << str << endl;
}
2️⃣练习升级:把字符串中遇到的空格替换成20%
这就要引入erase
:删除字符串中的字符
void test_string9()
{
//在空格的地方插入一个%
string str("JDG NB 总冠军");
for (size_t i = 0; i < str.size(); ++i)
{
if (str[i] == ' ')
{
str.insert(i, "20%");
i += 3;
}
}
//再把空格删除掉哦
for (size_t i = 0; i < str.size(); ++i)
{
if (str[i] == ' ')
{
str.erase(i, 1);
}
}
cout << str << endl;
}
ps:最好不要自行挪动数据,因为[]
会检查下标位置必须要小于size
的,如果真的要挪动,要resize
一下,增加长度
也有一种空间换时间的方法:创建新的串遍历,效率O(N)
void test_string9()
{
string str("JDG NB 总冠军");
string newstr;
for (size_t i = 0; i < str.size(); ++i)
{
if (str[i] != ' ')
{
newstr += str[i];
}
else
{
newstr += "20%";
}
}
cout << newstr << endl;
}
八、String operations 字符串操作
打印字符串,都能打印,但意义不同 ——
🤞前者是string类的流插入运算符的重载,以对象size
为准,size是多少打印多少
后者是以常量字符串对象\0为准,遇到\0
就结束(符合c语言标准)
所以说
\0
不一定是结束标志,在string里会被忽视
主要作用还是与函数接口接合——
string file("test.txt");
FILE* fout = fopen(s.c_str(), "w");//打印文件
![在这里插入图片描述](https://img-blog.csdnimg.cn/631a160b51da4d7e9729bbeb05c5295d.png
🌍substr 子串
➰· 取当前串的一个子串
len
:如果len比能取到的串长或使用缺省值npos,都是能取多少取多少
🌍查找 find & rfind
🌊 1. 从字符串pos位置
从前向后找字符c/字符串,返回该字符在字符串中的位置,找不到就返回npos
🌊 2. 从字符串pos位置倒着找找字符c/字符串,返回该字符在字符串中的位置
💢小练习:取字符串的后缀
void test_string11()
{
string str("test.cpp");
//找出后缀
size_t pos = str.rfind('.');//面对多后缀的最好用 rfind
if (pos != string::npos)
{
//string buff = str.substr(pos, str.size() - pos);
string buff = str.substr(pos);//因为是取到结束
cout << buff << endl;
}
}
但是这样写有没有说明问题呢?如果后缀是test.cpp.tar.zip
呢?要取最后一个后缀
这样就要将find
——》 rfind
,即可解决
💢解析出网址的这三个部分:协议 - 域名 - 资源
#include<iostream>
#include<string>
using namespace std;
int main()
{
string url = "https://cplusplus.com/reference/string/string/substr/";
size_t pos1 = url.find("://");
if (pos1 == string::npos)
{
cout << "非法字符串" << endl;
return;
}
//取协议
string protocol = url.substr(0, pos1);
cout << protocol << endl;
size_t pos2 = url.find('/', pos1 + 3);
if (pos1 == string::npos)
{
cout << "非法字符串" << endl;
return;
}
string domain = url.substr(pos1 + 3, pos2 - pos1 - 3);//取域名
cout << domain << endl;
string uri = url.substr(pos2 + 1);//取资源
cout << uri << endl;
}
💢find 和find_first_of 区别
find_first_of:只要出现要寻找的串里的任意字符都找出来
吐槽一下:find_first_of
更应该叫find_any_of,但我们要尊重语法
九、非成员函数重载
💦流插入&流提取
注意注意:流插入和流提取都是以空格、回车
作为结束标志的。这意味着如果想要输入一个字符串,最终可能只读入了一个单词,剩余的留在缓冲区里。
于是我们引入了getline
,做题会遇到
💦getline
遇到换行才结束
💢小练习:输出一个整数,表示输入字符串最后一个单词的长度
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
getline(cin,str);
size_t pos = str.rfind(' ');
if(pos != string::npos)
{
cout<<str.size()-pos-1<<endl;
}
else{
cout<<str.size()<<endl;
}
}
💦to_string
void test_string12()
{
//整形转字符串
int ival;
double dval;
cin >> ival >> dval;
string istr = to_string(ival);
string dstr = to_string(dval);
cout << istr << endl;
cout << dstr << endl;
//字符串转整形
istr = "9999";
dstr = "9999.99";
ival = stoi(istr);
dval = stod(dstr);
}
重要的事情说三遍:不会的查文档,不会的查文档,不会的查文档!!
十、 vs和g++下string结构的说明(了解)
🎉VS下string结构的说明:
string
总共占28个字节,内部结构稍微复杂一点,先是有一个联合体,联合体用来定义string中字符串的存储空间:
- 当字符串长度小于16时,使用内部固定的字符数组来存放
- 当字符串长度大于16时,从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger one
value_type _Buf[_BUF_SIZE];
pointer _Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这种设计也是有一定道理的,大多数情况下字符串的长度都小于16,那string对象创建好之后,内部已经有了16个字符数组的固定空间,不需要通过堆创建,效率高。
其次:还有一个size_t字段保存字符串长度,一个size_t字段保存从堆上开辟空间总的容量, 最后:还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节。
🎉g++下string的结构
G++下,string是通过写时拷贝实现的,string对象总共占4个字节,内部只包含了一个指针,该指针将来指向一块堆空间,内部包含了如下字段:
- 空间总大小
- 字符串有效长度
- 引用计数
- 指向堆空间的指针,用来存储字符串。
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
📢写在最后
1024程序节,快要来了,大家会怎么样过呢