• C++【STL】【string类】

    目录

    string类的常用接口说明 

    1. string类对象的常见构造

    2. string类对象的容量操作 

    3. string类对象的访问及遍历操作

    【LeetCode】反转字符串 

    string的迭代器

    范围for 

    反向迭代器 

    常量正向/反向迭代器

    4. string类对象的修改操作 

    find vs rfind

    【牛客】字符串最后一个单词的长度 

    getline 

    5. string类非成员函数  

    6. string结构的说明

    g++下string的结构 

    reserve/resize可以提前扩容好大小

    7.插入擦除函数

    insert

    erase

    【LeetCode】字符串相加

    8.字符串转换相关的函数 

    to_string vs stoi

    部分练习 

     【Leetcode】字符串中的第一次出现的唯一一次的字符​​​​​​​

    【LeetCode】验证回文串

    C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

    在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。 

    1. 字符串是表示字符序列的类
    2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
    3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
    4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
    5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
    总结：
    1. string是表示字符串的字符串类
    2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作 

    3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
    4. 不能操作多字节或者变长字符的序列。
    在使用string类时，必须包含#include头文件以及using namespace std;

    string - C++ Reference

    打印asc码中的字符 

    1. void test12()
    2. {
    3.     for(unsigned char ch=0;ch<128;++ch)
    4.     {
    5.         cout<" ";
    6.     }
    7. }
    8. int main()
    9. {
    10.     test12();
    11.     return 0;
    12. }

    asc码表中的部分字符时不可以显式打印出来的 

    string类的常用接口说明 

    string内部可能就是下面的结构

    1. _str //存储具体的字符串
    2. _size //存储具体字符串的长度
    3. _capacity //存储字符串的最大长度

    1. string类对象的常见构造

    （constructor）函数名称功能说明
    string构造空的string类对象，即空字符集
    string（const char*s）用C-string来构造string类对象
    string（size_t n,char c）string类对象中包含n个字符c
    string(const string&c)拷贝构造函数
    1. #include
    2. #include 
    3. using namespace std;
    4. void test()
    5. {
    6.     //构造空参的字符串
    7.     string s1;
    8.     //构造传参的字符串
    9.     string s2("hello world");
    10.     //由于隐式类型转换，将hello world转换成了一个字符串对象然后拷贝给s10。（编译器优化后可能会变成直接构造）
    11.     string s10="hello world";
    12.     s1=s2;
    13.     s1="xxxx";//赋值
    14.     s1='y';
    15.     //输入字符串
    16.     cin>>s1;
    17.     //打印字符串
    18.     cout<"  "<
    19.  
    20.     //拷贝构造
    21.     string s3(s2);
    22.     cout<
    23.  
    24.     //拷贝构造一部分
    25.     //如果省略掉最后一个参数，就默认从pos位置拷贝到最后
    26.     string s4(s2,6);
    27.     cout<
    28.     //从第六个位置开始拷贝两个。
    29.     //如果拷贝的长度超出了字符串的最大长度，就拷贝到结尾就停止了
    30.     string s5(s2,6,2);
    31.     cout<
    32.  
    33.     //这里utf8的字符集对于中文是三个字节一个中文字符，所以一共会将前7个字符打印出来
    34.     string s6("喝了这碗鸡汤，我肯定得死，你们也白想活着！",21);
    35.     cout<
    36.  
    37.     //将x重复打印10次，但是好像不支持中文字符
    38.     string s7 (10, 'x');
    39.     cout<
    40. }
    41.  
    42. int main()
    43. {
    44.     test();
    45.     return 0;
    46. }

     

    2. string类对象的容量操作 

    函数名称功能说明
    size返回字符串的有效字符长度
    length返回字符串有效字符长度
    capacity返回空间的总大小
    empty检测字符串释是否为空串，是返回TRUE，否则返回FALSE
    clear清空有效字符
    reverve为字符串预留空间
    resize将有效字符的个数改成n个，多出的空间用字符c填充

    注意：
    1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
    2. clear()只是将string中有效字符清空，不改变底层空间大小。

    3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
    4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

    1. #include
    2. #include 
    3.  
    4. using namespace std;
    5. void Teststring1()
    6. {
    7.     // 注意：string类对象支持直接用cin和cout进行输入和输出
    8.     string s("hello, world!!!");
    9.     //size是我们真实的有效的字符长度，上面s的长度就是15
    10.     cout << s.size() << endl;
    11.     //length主要是为了兼容以前的C风格代码准备的
    12.     cout << s.length() << endl;
    13.     //这里的capacity指的值系统给我们字符串预开辟的空间大小
    14.     cout << s.capacity() << endl;
    15.     cout << s << endl;
    16.  
    17.     // 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
    18.     s.clear();
    19.     cout << s.size() << endl;
    20.     cout << s.capacity() << endl;
    21.  
    22.     // 将s中有效字符个数增加到10个，多出位置用'a'进行填充
    23.     // “aaaaaaaaaa”
    24.     s.resize(10, 'a');
    25.     cout << s.size() << endl;
    26.     cout << s.capacity() << endl;
    27.  
    28.     // 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
    29.     // "aaaaaaaaaa\0\0\0\0\0"
    30.     // 注意此时s中有效字符个数已经增加到15个
    31.     s.resize(15);
    32.     cout << s.size() << endl;
    33.     cout << s.capacity() << endl;
    34.     cout << s << endl;
    35.  
    36.     // 将s中有效字符个数缩小到5个
    37.     s.resize(5);
    38.     //有效字符为5个的话，原先多出来的字符串就会被截断了
    39.     cout << s.size() << endl;
    40.     //预先开辟的容量大小是不会变得
    41.     cout << s.capacity() << endl;
    42.     cout << s << endl;
    43. }
    44.  
    45. int main(int argc, char *argv[])
    46. {
    47.     Teststring1();
    48.     return 1;
    49. }

    1. void Teststring2()
    2. {
    3.     string s;
    4.     // 测试reserve是否会改变string中有效元素个数
    5.     s.reserve(100);
    6.     cout << s.size() << endl;
    7.     cout << s.capacity() << endl;
    8.  
    9.     // 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
    10.     s.reserve(50);
    11.     cout << s.size() << endl;
    12.     cout << s.capacity() << endl;
    13. }
    14. int main()
    15. {
    16.     Teststring2();
    17.     return 1;
    18. }

    从下面的测试代码中可以看出如果我们后一次开辟的空间大小比前一次小的话，其底层还是保持原先大的空间。 

    1. void Teststring2()
    2. {
    3.     string s;
    4.     // 测试reserve是否会改变string中有效元素个数
    5.     s.reserve(50);
    6.     cout << s.size() << endl;
    7.     cout << s.capacity() << endl;
    8.  
    9.     // 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
    10.     s.reserve(100);
    11.     cout << s.size() << endl;
    12.     cout << s.capacity() << endl;
    13. }
    14. int main()
    15. {
    16.     Teststring2();
    17.     return 1;
    18. }

    从下面的测试结果中可以看出，如果我们原先开辟的空间较小，然后我们又重新开辟了一块较大的空间的时候，我们的底层开辟的空间就会变大。 

    3. string类对象的访问及遍历操作

    函数名称

    功能说明

    operator[] （重点）

    返回pos位置的字符，const   string类对象调用

    begin+ end

    begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器

    rbegin + rend

    begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器

    范围for

    C++11支持更简洁的范围for的新遍历方式

    其operator使我们的string能够像char[]一样随机提取元素，其底层的原理可能如下。

    1. char& operator[](size_t pos)
    2. {
    3.     assert(pos
    4.     return _str[pos];
    5. }

     所以s1[0]='x'就等价于s1.operator[](0);

    引用做返回

    1、减少拷贝

    2、修改返回对象

    1. void test3()
    2. {
    3.     string s1("helloworld");
    4.     for(size_t i=0;isize();i++)
    5.     {
    6.         s1[i]++;
    7.     }
    8.     cout<
    9.  
    10.     const string s2("helloworld");
    11.     for(size_t i=0;ilength();i++)
    12.     {
    13.         cout<" ";
    14.     }
    15.     cout<<" "<
    16.     //范围越界会报错
    17. //    cout<
    18. }
    19. int main()
    20. {
    21.     test3();
    22.     return 0;
    23. }

     

    【LeetCode】反转字符串 

    力扣

    给你一个字符串 s ，根据下述规则反转字符串：

    • 所有非英文字母保留在原有位置。
    • 所有英文字母（小写或大写）位置反转。

    对于这道题在我们的c++中就可以采取我们下面的写法

    1. class Solution {
    2. public:
    3.     string reverseOnlyLetters(string s) {
    4.         size_t begin=0,end=s.size()-1;
    5.         while(begin < end)
    6.         {
    7.             while(beginisalpha(s[begin]))
    8.             {
    9.                 ++begin;
    10.             }
    11.             while(beginisalpha(s[end]))
    12.             {
    13.                 --end;
    14.             }
    15.             swap(s[begin],s[end]);
    16.             ++begin;
    17.             --end;
    18.         }
    19.  
    20.         return s;
    21.     }
    22. };

    string的迭代器

    iterator是一个像指针一样的类型，有可能就是指针，也有可能不是指针，但是它的用法像指针一样。

    字符串的迭代器

    string::iterator 

    容器的迭代器

    vector::iterator

    list::iterator

    1. void test4()
    2. {
    3.     string s="hello world";
    4.     string::iterator it =s.begin();
    5. //对于string和vector可以将!=改成<但是对于别的不一定
    6. //因为string和vector存储的是连续的数据，并且用的是原生的指针，
    7. //对于别的STL可不一定。
    8.     while(it!=s.end())
    9.     {
    10.         cout<<*it<<" ";
    11.         ++it;
    12.     }
    13.     cout<
    14.  
    15. //iterator是所有容器通用访问方式，用法类似的
    16.     list<int> lt(10,1);
    17.     list<int>::iterator lit=lt.begin();
    18.     while(lit!=lt.end())
    19.     {
    20.         cout<<*lit <<" ";
    21.         ++lit;
    22.     }
    23.     cout<
    24. }
    25.  
    26. int main()
    27. {
    28.     test4();
    29.     return 0;
    30. }

      

     但是string不喜欢用迭代器，因为[]更好用。

    vector不喜欢用iterator，因为[]更好用

    list/map/set……只能用迭代器访问

    iterator是所有容器通用的访问方式，并且用法是类似的。

    范围for 

    范围for相较于迭代器，是不可以反向的

    1. void test5()
    2. {
    3.     //范围for -自动迭代，自动判断结束。
    4.     //依次取s中的每个字符，赋值给ch
    5.     string s="hello world";
    6.     for(auto ch :s)
    7.     {
    8.         cout<" ";
    9.     }
    10.     cout<
    11.  
    12.     //范围for对于容器都能支持
    13.     list<int> lt(10,1);
    14.     for(auto e :lt)
    15.     {
    16.         cout<" ";
    17.     }
    18.     cout<
    19.     //范围for的底层其实就是迭代器
    20. }
    21. int main()
    22. {
    23.     test5();
    24.     return 0;
    25. }

    反向迭代器 

    1. void test6()
    2. {
    3.     string s("hello");
    4.     string::reverse_iterator  rit=s.rbegin();
    5.     while(rit !=s.rend())
    6.     {
    7.         cout<<*rit<<"  ";
    8.         ++rit;
    9.     }
    10.     cout<
    11. }
    12. int main()
    13. {
    14.     test6();
    15.     return 0;
    16. }

    常量正向/反向迭代器

    常量迭代器过程中得到的数据不可修改

    1. void PrintString(const string&str)
    2. {
    3. //常量正向迭代器
    4.     string::const_iterator it=str.begin();
    5. //可以使用自动推断
    6. //    auto it=str.begin();
    7.     while(it!=str.end())
    8.     {
    9.         cout<<*it<<" ";
    10.         ++it;
    11.     }
    12.     cout<
    13.  
    14.     //常量反向迭代器
    15.     string::const_reverse_iterator rit=str.rbegin();
    16. //可以使用自动推断
    17. //    auto it=str.begin();
    18.     while(rit!=str.rend())
    19.     {
    20.         cout<<*rit<<" ";
    21.         ++rit;
    22.     }
    23.     cout<
    24. }
    25.  
    26. int main()
    27. {
    28.     string s("hello");
    29.     PrintString(s);
    30.     return 0;
    31. }

    4. string类对象的修改操作 

    函数名称

    功能说明

    push_back

    在字符串后尾插字符c

    append

    在字符串后追加一个字符串

    operator+= (重点)

    在字符串后追加字符串str

    c_str(重点)

    返回C格式字符串

    find + npos(重点)

    从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置

    rfind

    从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置

    substr

    在str中从pos位置开始，截取n个字符，然后将其返回

    注意：
    1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
    2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

    1. // 测试string：
    2. // 1. 插入(拼接)方式：push_back  append  operator+=
    3. // 2. 正向和反向查找：find() + rfind()
    4. // 3. 截取子串：substr()
    5. // 4. 删除：erase
    6. void Teststring5()
    7. {
    8.     string str;
    9.     str.push_back(' ');   // 在str后插入空格
    10.     str.append("ho");  // 在str后追加一个字符"ho"
    11.     str += 'm';           // 在str后追加一个字符'm'
    12.     str += "mo";          // 在str后追加一个字符串"mo"
    13. //这里使用的是流输出
    14. //打印用的是string的重载
    15.     cout << str << endl;
    16. //这里用的是const char*的重载
    17.     cout << str.c_str() << endl;   // 以C语言的方式打印字符串
    18.     //c_str()生成一个const char *指针，指向首元素的地址
    19.  
    20.     // 获取file的后缀
    21.     string file("string.cpp");
    22.     size_t pos = file.rfind('.');
    23.     cout<
    24.     string suffix(file.substr(pos, file.size() - pos));
    25.     cout << suffix << endl;
    26.  
    27.     // npos是string里面的一个静态成员变量
    28.     // static const size_t npos = -1;
    29.  
    30.     // 取出url中的域名
    31.     string url("http://www.cplusplus.com/reference/string/string/find/");
    32.     cout << url << endl;
    33.     size_t start = url.find("://");
    34.     //会找到://第一个字符所在的位置4
    35.     cout<
    36.     if (start == string::npos)
    37.     {
    38.         cout << "invalid url" << endl;
    39.         return;
    40.     }
    41.     //跳过://的位置
    42.     start += 3;
    43.     size_t finish = url.find('/', start);
    44.     string address = url.substr(start, finish - start);
    45.     cout << address << endl;
    46.  
    47.     // 删除url的协议前缀
    48.     pos = url.find("://");
    49.     //pos+3是将://全部删光
    50.     url.erase(0, pos + 3);
    51.     cout << url << endl;
    52. }
    53.  
    54. int main()
    55. {
    56.     Teststring5();
    57.     return 1;
    58. }

    对于c_str()是为了兼容c语言，就如fopen中读取的字符串只能是c语言的char[]类型，所以我们下面一定要这样写才能兼容fopen

    1. void test10()
    2. {
    3.     string filename("cplustext/main.cpp");
    4.     FILE* fout=fopen(filename.c_str(),"r");
    5.     assert(fout);
    6.     char ch=fgetc(fout);
    7.     while(ch !=EOF)
    8.     {
    9.         cout<
    10.         ch=fgetc(fout);
    11.     }
    12. }
    13. int main()
    14. {
    15.     test10();
    16.     return 1;
    17. }

     

    对于string 和string.c_str()进一步的测试 

    1. void test11()
    2. {
    3.     string filename("test.cpp");
    4.     cout<
    5.     cout<c_str()<
    6.     filename+='\0';
    7.     filename+="string.cpp";
    8.     //\0不是可以显示的字符，所以打印不出来，会是一个奇怪的字符
    9.     cout<//以string对象的size为准输出字符
    10.     cout<c_str()<//常量字符串对象，遇到\0就停止打印。
    11.  
    12.     cout<size()<
    13.     string copy=filename;
    14.     cout<
    15.  
    16. }
    17. int main()
    18. {
    19.     test11();
    20.     return 0;
    21. }

     

    1. void test7()
    2. {
    3.     string s("砸");
    4.     //push_back只支持一个一个字符从后面插入
    5.     s.push_back(' ');
    6.     s.push_back('-');
    7.     //append可以append一整个字符串
    8.     s.append("瓦鲁多!!");
    9.     cout<
    10.  
    11.     string str1("赛扣泥");
    12.     string str2("嗨忒鸭子大,哈哈");
    13.     //+=的底层就是push_back和append
    14.     s+='@';
    15.     s+=str1;
    16.     s+=str2;
    17.     cout<
    18.  
    19.     //可以直接把str1从开头到结尾全部追加到s中
    20.     s.append(str1.begin(),str1.end());
    21.     cout<
    22.     //可以指定追加的范围
    23.     string copy(s.begin()+3,s.end()-3);
    24.     cout<
    25. }
    26. int main()
    27. {
    28.     test7();
    29.     return 0;
    30. }

     ​​​​​​​

    find vs rfind

    查找函数

    1. void test13()
    2. {
    3.     string filename("kono.dio.da");
    4.     //查找后缀，默认从0位置开始查找
    5.     //返回第一个匹配的位置，如果匹配不到就返回string::npos，也就是整型的最大值
    6.     size_t pos=filename.find('.');
    7.     if(pos!=string::npos)
    8.     {
    9.         string  suff=filename.substr(pos,filename.size()-pos);
    10.         cout<
    11.     }
    12.     //返回最后一个匹配到的位置
    13.     size_t pos2=filename.rfind('.');
    14.     if(pos!=string::npos)
    15.     {
    16.         string  suff=filename.substr(pos2,filename.size()-pos);
    17.         cout<
    18.     }
    19.  
    20. }
    21. int main()
    22. {
    23.     test13();
    24.     return 0;
    25. }

     利用上面的函数，编写一个分解url成协议，域名和后面的资源名的函数

    1. void DealUrl(const string&url)
    2. {
    3.     size_t pos1=url.find("://");
    4.     if(pos1==string::npos)
    5.     {
    6.         cout<<"非法的url"<
    7.         return;
    8.     }
    9.     string protocol=url.substr(0,pos1);
    10.     cout<
    11.  
    12.     size_t pos2=url.find('/',pos1+3);
    13.     if(pos2==string::npos)
    14.     {
    15.         cout<<"非法的url"<
    16.         return;
    17.     }
    18.     string domin=url.substr(pos1+3,pos2-pos1-3);
    19.     cout<
    20.  
    21.     string uri=url.substr(pos2+1);
    22.     cout<
    23. }
    24. void test14()
    25. {
    26.     string url1="https://www.cplusplus.com/reference/string/string/?kw=string";
    27.     cout<
    28.     DealUrl(url1);
    29. }
    30. int main()
    31. {
    32.     test14();
    33.     return 0;
    34. }

    【牛客】字符串最后一个单词的长度 

    描述

    计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾） 

    输入描述：

    输入一行，代表要计算的字符串，非空，长度小于5000。

    输出描述：

    输出一个整数，表示输入字符串最后一个单词的长度。

    字符串最后一个单词的长度_牛客题霸_牛客网

    getline 

    如果是的cin>>str的话，在读取到空格或者回车就会停止读取，需要使用getline来读取一行数据 

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main(){
    6.     string str;
    7. //     cin>>str;
    8.     //找到最后一个空格
    9.     getline(cin,str);
    10.     size_t pos=str.rfind(' ');
    11.     if(pos !=string::npos)
    12.     {
    13.         cout<size()-pos-1<
    14.     }
    15.     else
    16.     {
    17.         cout<size()<
    18.     }
    19. }

    5. string类非成员函数  

    函数

    功能说明

    operator+

    尽量少用，因为传值返回，导致深拷贝效率低

    operator>> （重点）

    输入运算符重载

    operator<< （重点）

    输出运算符重载

    getline （重点）

    获取一行字符串

    relational operators （重点）

    大小比较

    6. string结构的说明

    1. void test8()
    2. {
    3.     string s1;
    4.     string s2("111111");
    5.     cout<max_size()<
    6.     cout<max_size()<
    7.  
    8.     cout<capacity()<
    9.     cout<capacity()<
    10. }
    11. int main()
    12. {
    13.     test8();
    14.     return 0;
    15. }

     capacity是会动态变化的，但是max_size是确定的

    1. void TestPushBack()
    2. {
    3.     string s;
    4.     //这里的容量是没有计算\0的空间
    5.     size_t sz = s.capacity();
    6.     cout << "capacity changed: " << sz << '\n';
    7.     cout << "making s grow:\n";
    8.     for (int i = 0; i < 100; ++i)
    9.     {
    10.         s.push_back('c');
    11.         if (sz != s.capacity())
    12.         {
    13.             sz = s.capacity();
    14.             cout << "capacity changed: " << sz << '\n';
    15.         }
    16.     }
    17. }
    18.  
    19. int main()
    20. {
    21.     TestPushBack();
    22.     return 0;
    23. }

    可以看到在clion的编译器下，初始开辟是22，

    在vs下面可能为15，

    在Linux的g++下可能为1->2->4->8…… 

    在Linux的g++下面的编译结果是这样的 

    g++下string的结构 

    G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：
    空间总大小
    字符串有效长度
    引用计数 

    1. struct _Rep_base
    2. {
    3.     size_type _M_length;
    4.     size_type _M_capacity;
    5.     _Atomic_word _M_refcount;
    6. };

    reserve/resize可以提前扩容好大小

    reserve是保留 开空间

    resize是开空间+初始化

    1. void TestPushBack()
    2. {
    3.     string s;
    4.     s.reserve(1000);
    5.     //这里的容量是没有计算\0的空间
    6.     size_t sz = s.capacity();
    7.     cout << "capacity changed: " << sz << '\n';
    8.     cout << "making s grow:\n";
    9.     for (int i = 0; i < 100; ++i)
    10.     {
    11.         s.push_back('c');
    12.         if (sz != s.capacity())
    13.         {
    14.             sz = s.capacity();
    15.             cout << "capacity changed: " << sz << '\n';
    16.         }
    17.     }
    18. }
    19.  
    20. int main()
    21. {
    22.     TestPushBack();
    23.     return 0;
    24. }

     

    测试resize 

    1. void TestPushBack()
    2. {
    3.     string s;
    4.     s.resize(1000);
    5.     //这里的容量是没有计算\0的空间
    6.     size_t sz = s.capacity();
    7.     cout << "capacity changed: " << sz << '\n';
    8.     cout << "making s grow:\n";
    9.     for (int i = 0; i < 100; ++i)
    10.     {
    11.         s.push_back('c');
    12.         if (sz != s.capacity())
    13.         {
    14.             sz = s.capacity();
    15.             cout << "capacity changed: " << sz << '\n';
    16.         }
    17.     }
    18. }
    19.  
    20. int main()
    21. {
    22.     TestPushBack();
    23.     return 0;
    24. }

    这里为什么reverse在后面添加数据的时候并不会继续扩容，而resize会继续扩容呢？

    这是因为reverse是提前开辟空间，接下来存就是从头开始存了，而resize开辟了空间，接着就是从这个空间往后存了。 

    在clion的环境下，当开辟的大小到1008时，就会扩容到2015了

    7.插入擦除函数

    insert

    下面的insert插入，erase擦除或者是replace都会是要大量移动字符串中元素的，所以效率都不高

    1. #include
    2. #include 
    3.  
    4. using namespace std;
    5. void test8()
    6. {
    7.     //在每个空格的位置插入百分号
    8.     string str("ko no dio da");
    9.     for(size_t i=0;isize();)
    10.     {
    11.         if(str[i]==' ')
    12.         {
    13.             str.insert(i,"20%");
    14.             //这个4是20%和下一个空格，从而达到下一个单词
    15.             i+=4;
    16.         }
    17.         else
    18.         {
    19.             ++i;
    20.         }
    21.     }
    22.     cout<
    23. }
    24.  
    25. int main()
    26. {
    27.     test8();
    28.     return 1;
    29. }

    erase

    1. #include
    2. #include 
    3.  
    4. using namespace std;
    5. void test8()
    6. {
    7.     //在每个空格的位置插入百分号，并且不保留空格
    8.     string str("ko no dio da");
    9.     for(size_t i=0;isize();)
    10.     {
    11.         if(str[i]==' ')
    12.         {
    13.             str.erase(i,1);
    14.             str.insert(i,"20%");
    15.             I+=3;
    16.         }
    17.         else
    18.         {
    19.             ++i;
    20.         }
    21.     }
    22.     cout<
    23. }
    24.  
    25. int main()
    26. {
    27.     test8();
    28.     return 1;
    29. }

     或者采用下面用空间换时间的方式

    1. #include
    2. #include 
    3.  
    4. using namespace std;
    5. void test8()
    6. {
    7.     //在每个空格的位置插入百分号
    8.     string str("ko no dio da");
    9.     for(size_t i=0;isize();)
    10.     {
    11.         if(str[i]==' ')
    12.         {
    13.             str.erase(i,1);
    14.             str.insert(i,"20%");
    15.             i+=4;
    16.         }
    17.         else
    18.         {
    19.             ++i;
    20.         }
    21.     }
    22.     cout<
    23. }
    24. void test9()
    25. {
    26.     string newstr;
    27.     string str("ko no dio da");
    28.     for(size_t i=0;isize();++i)
    29.     {
    30.         if(str[i]!=' ')
    31.         {
    32.             newstr+=str[i];
    33.         }
    34.         else
    35.         {
    36.             newstr+="20%";
    37.         }
    38.     }
    39.     cout<
    40. }
    41. int main()
    42. {
    43.     test9();
    44.     return 1;
    45. }

     

    【LeetCode】字符串相加

    给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。

    你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。

    来源：力扣（LeetCode）
    链接：力扣
    著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    第一种方法，就是将两个数据从尾部相加，如果有进位，就将进位保存在一个临时的变量中，参与下一次的相加，然后将相加后的数据头插到结果的字符串中，直到两个数据都全部完成相加。 

    1. class Solution {
    2. public:
    3.     string addStrings(string num1, string num2) {
    4. //分别获取两个字符串的数组的最大下标
    5.         int end1=num1.size()-1,end2=num2.size()-1;
    6. //用next来存储进位
    7.         int next=0;
    8. //创建存储结果的字符串
    9.         string strRet;
    10. //只要有一个字符串中还有数据就要继续循环
    11.         while(end1>=0 || end2>=0)
    12.         {
    13. //如果读取到的非空的话，就将字符串转换为数值
    14.             int val1=end1>=0 ?num1[end1]-'0' :0;
    15.             int val2=end2>=0 ?num2[end2]-'0' :0;
    16.  
    17.             int ret=val1+val2+next;
    18. //进位最多也只是9+9，最大也仅仅是1
    19.             next=ret>9 ? 1:0;
    20. //可以采用insert指定在0号位置，插入一个元素，然后将我们计算过后的结果转换为字符串传入
    21.             // strRet.insert(0,1,(ret%10)+‘0’);
    22. //或者是使用迭代器，将迭代器的开始位置传入，然后将我们计算过后的结果转换为字符串传入
    23.             strRet.insert(strRet.begin(),'0'+(ret%10));
    24. //循环迭代
    25.             --end1;
    26.             --end2;
    27.         }
    28.         //处理1+9之类的情况，如果尾部为0，而十位上的读取都已经没有数据了，
    29.         //但是还有进位的话就需要再头插1
    30.         if(next)
    31.         {
    32.             strRet.insert(strRet.begin(),'1');
    33.         }
    34.         return strRet;
    35.     }
    36.     
    37. };

    上面头插的版本由于头插的效率比较低，需要遍历字符串我们可以看到我们的代码运行仅仅打败了7%，所以我们可以采用下面先尾插然后将整个字符串逆置的思路来提升我们的代码运行效率

    1. class Solution {
    2. public:
    3.     string addStrings(string num1, string num2) {
    4.         int end1=num1.size()-1,end2=num2.size()-1;
    5.         int next=0;
    6.         string strRet;
    7.         while(end1>=0 || end2>=0)
    8.         {
    9.             int val1=end1>=0 ?num1[end1]-'0' :0;
    10.             int val2=end2>=0 ?num2[end2]-'0' :0;
    11.             int ret=val1+val2+next;
    12.             next=ret>9 ? 1:0;
    13.  
    14.             //尾插
    15.             strRet+=('0'+ ret%10);
    16.  
    17.             --end1;
    18.             --end2;
    19.         }
    20.         //如果next还有进位就需要再尾插1
    21.         if(next==1)
    22.         {
    23.             strRet+='1';
    24.         }
    25.  
    26.         //逆置
    27.         reverse(strRet.begin(),strRet.end());
    28.         return strRet;
    29.     }
    30.     
    31. };

    【Leetcode】【字符串相乘】_桜キャンドル淵的博客-CSDN博客 

    8.字符串转换相关的函数 

    to_string vs stoi

    1. void test15()
    2. {
    3.     int ival;
    4.     double dval;
    5.     cin>>ival>>dval;
    6.     string istr= to_string(ival);
    7.     //默认保持小数点后6位
    8.     string dstr= to_string(dval);
    9.     cout<
    10.     cout<
    11.  
    12.     istr="9999";
    13.     dstr="9999.99999";
    14.     //string to int
    15.     ival=stoi(istr);
    16.     dval=stoi(dstr);
    17.     cout<
    18.     cout<
    19. }
    20. int main()
    21. {
    22.     test15();
    23.     return 0;
    24. }

    部分练习 

     【Leetcode】字符串中的第一次出现的唯一一次的字符​​​​​​​

    给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

    力扣

    1. class Solution {
    2. public:
    3.     int firstUniqChar(string s) {
    4. //定义一个计数数组
    5.         int a[26]={0};
    6.         int len=s.size();
    7.         for(int i=0;i
    8.         {
    9.             a[s[i]-'a']++;
    10.         }
    11.         for(int i=0;i
    12.         {
    13.             if(a[s[i]-'a']==1)
    14.             {
    15.                 return i;
    16.             }
    17.         }
    18.         return -1;
    19.     }
    20. };

    【LeetCode】验证回文串

    给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

    说明：本题中，我们将空字符串定义为有效的回文串。

    力扣

    1. class Solution {
    2. public:
    3.     bool isPalindrome(string s) {
    4.         //大写字符转小写字符
    5.         for(auto& ch :s)
    6.         {
    7.             if(ch >='A'&&ch<='Z')
    8.             {
    9.                 ch+=32;
    10.             }
    11.         }
    12.         int begin=0,end=s.size()-1;
    13.         while(begin
    14.         {
    15.             while(beginisalnum(s[begin]) )
    16.             {
    17.                 ++begin;
    18.             }
    19.             while(beginisalnum(s[end]) )
    20.             {
    21.                 --end;
    22.             }
    23.             if(s[begin]==s[end])
    24.             {
    25.                 ++begin;
    26.                 --end;
    27.             }
    28.             else
    29.             {
    30.                 return false;
    31.             }
    32.         }
    33.         return true;
    34.     }
    35. };

  • 相关阅读:
    C/C++ 代码中使用 CMake 工程目录
    常见荧光染料修饰多种基团及其激发和发射波长数据一览数据
    Spring框架异常大全
    如何使用AuraDB构建Java微服务
    Yolov5进阶之五GPU环境搭建
    el-table的一些样式总结
    TCP的三次握手和四次挥手
    农场养殖农产品商城小程序搭建
    你想要的异常知识点都在这里了
    m4a转换成mp3，音频格式轻松转换
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/126232376