C++STL之string类

于 2022-01-07 15:01:39 发布
阅读量226 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM算法 文章标签： c++ c语言 开发语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52023825/article/details/122364342
本文介绍了C++标准模板库(STL)中的string类，包括其基本概念、创建和读写操作、比较与查找、插入删除、拼接、排序、分割和子串提取等实用技巧。通过实例演示了如何高效地处理字符串任务。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++万能头文件

#include<bits/stdc++.h>

STL简介

Standard Template Library，缩写：STL

STL 是⼀个 C++ 软件库，⾥⾯包含算法（algorithms）、容 器（containers）、函数（functions）、迭代器（iterators）

string类

string是STL中的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string读入输出，类似于C语言中的字符数组，由于C++的算法库对string类也有着很好的支持，大多时候字符串处理的问题使用string要比字符数组更加方便。

博客推荐：
https://www.cnblogs.com/nanyangzp/p/3607534.html

创建string类型变量

string s;// 直接创建一个空的（大小为0）的string类型变量s
string s=*char;// 创建string时直接用字符串内容对其赋值，注意字符串要用双引号""
string s(int n,char c); //创建一个string，由n个c组成，注意c是字符型要用单括号’’
读入string
cin>>s; //读入s，遇到空格或回车停止，无论原先s是什么内容都会被新读入的数据替代
getline(cin,s); //读入s，空格也同样会读入，直到回车才会停止输出string
cout<<s; //将s全部输出到一行（不带回车）

string类函数

  1. =, s.assign() // 赋以新值

  2. swap() // 交换两个字符串的内容

  3. +=, s.append(), s.push_back() // 在尾部添加字符

  4. s.insert() // 插入字符

  5. s.erase() // 删除字符

  6. s.clear() // 删除全部字符

  7. s.replace() // 替换字符

    • // 串联字符串

  9. ==,!=,<,<=,>,>=,compare() // 比较字符串

  10. size(),length() // 返回字符数量

  11. max_size() // 返回字符的可能最大个数

  12. s.empty() // 判断字符串是否为空

  13. s.capacity() // 返回重新分配之前的字符容量

  14. reserve() // 保留一定量内存以容纳一定数量的字符

  15. [ ], at() // 存取单一字符

  16. getline() // 从stream读取某值

  17. << // 将谋值写入stream

  18. copy() // 将某值赋值为一个C_string

  19. c_str() // 返回一个指向正规C字符串(C_string)的指针 内容与本string串相同 有’\0’

  20. data() // 将内容以字符数组形式返回 无’\0’

  21. s.substr() // 返回某个子字符串

  22. begin() end() // 提供类似STL的迭代器支持

  23. rbegin() rend() // 逆向迭代器

  24. get_allocator() // 返回配置器

string的构造函数

一. string的构造函数的形式：
string str：生成空字符串

string s(str)：生成字符串为str的复制品

string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值

string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值

string s(num ,c)：生成num个c字符的字符串

string s(str, stridx)：将字符串str中从下标stridx开始到字符串结束的位置作为字符串初值

举例

string str1;               //生成空字符串
string str2("123456789");  //生成"1234456789"的复制品
string str3("12345", 0, 3);//结果为"123"
string str4("012345", 5);  //结果为"01234"
string str5(5, '1');       //结果为"11111"
string str6(str2, 2);      //结果为"3456789"

#include <iostream>
#include <string>
using namespace std;

void test1()
{
    string str1;               //生成空字符串
    string str2("123456789");  //生成"1234456789"的复制品
    string str3("12345", 0, 3);//结果为"123"
    string str4("0123456", 5);  //结果为"01234"
    string str5(5, '1');       //结果为"11111"
    string str6(str2, 2);      //结果为"3456789"

    cout<<"str2:"<<str2<<endl;
    cout<<"str3:"<<str3<<endl;
    cout<<"str4:"<<str4<<endl;
    cout<<"str5:"<<str5<<endl;
    cout<<"str6:"<<str6<<endl;
}

int main()
{
    test1();
    return 0;
}

string的大小和容量

1. size()和length()：返回string对象的字符个数，他们执行效果相同。

2. max_size()：返回string对象最多包含的字符数，超出会抛出length_error异常

3. capacity()：重新分配内存之前，string对象能包含的最大字符数

void test2()
{
    string s("1234567");
    cout << "size=" << s.size() << endl;
    cout << "length=" << s.length() << endl;
    cout << "max_size=" << s.max_size() << endl;
    cout << "capacity=" << s.capacity() << endl;

}

stirng的字符串比较

1. C ++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string的比较(如 str<”hello”)。  
   在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小，  
   比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小(前面减后面)
   同时，string (“aaaa”) <string(aaaaa)。    

2. 另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。 
   他返回一个整数来表示比较结果，返回值意义如下：0：相等 1：大于 -1：小于 (A的ASCII码是65，a的ASCII码是97)

3. void test3()
   {
       // (A的ASCII码是65，a的ASCII码是97)
       // 前面减去后面的ASCII码，>0返回1，<0返回-1，相同返回0
       string A("aBcd");
       string B("Abcd");
       string C("123456");
       string D("123dfg");

       // "aBcd" 和 "Abcd"比较------ a > A
       cout << "A.compare(B)：" << A.compare(B)<< endl;                          // 结果：1
       
       // "cd" 和 "Abcd"比较------- c > A
       cout << "A.compare(2, 3, B):" <<A.compare(2, 3, B)<< endl;                // 结果：1
       
       // "cd" 和 "cd"比较 
       cout << "A.compare(2, 3, B, 2, 3):" << A.compare(2, 3, B, 2, 3) << endl;  // 结果：0


       // 由结果看出来：0表示下标，3表示长度
       // "123" 和 "123"比较 
       cout << "C.compare(0, 3, D, 0, 3)" <<C.compare(0, 3, D, 0, 3) << endl;    // 结果：0

   }

string的插入

//push_back() 和 insert()
也许你需要在string中间的某个位置插入字符串，这时候你可以用insert()函数，这个函数需要你指定一个安插位置的索引，被插入的字符串将放在这个索引的后面。 
s.insert(0,”my name”); 
s.insert(1,str); 
这种形式的insert()函数不支持传入单个字符，这时的单个字符必须写成字符串形式。为了插入单个字符，insert()函数提供了两个对插入单个字符操作的重载函数： 
insert(size_type index, size_type num, chart c)和insert(iterator pos, size_type num, chart c)。 
其中size_type是无符号整数，iterator是char*,所以，你这么调用insert函数是不行的： 
insert(0, 1, ‘j’);这时候第一个参数将转换成哪一个呢？ 
所以你必须这么写：insert((string::size_type)0, 1, ‘j’)！ 
第二种形式指出了使用迭代器安插字符的形式。

void  test4()
{
    string s1;

    // 尾插一个字符
    s1.push_back('a');
    s1.push_back('b');
    s1.push_back('c');
    cout<<"s1:"<<s1<<endl; // s1:abc

    // insert(pos,char):在制定的位置pos前插入字符char
    s1.insert(s1.begin(),'1');
    cout<<"s1:"<<s1<<endl; // s1:1abc
}

string的删除：

1. iterator erase(iterator p);//删除字符串中p所指的字符

2. iterator erase(iterator first, iterator last);//删除字符串中迭代器

区间[first,last)上所有字符

3. string& erase(size_t pos = 0, size_t len = npos);//删除字符串中从索引

位置pos开始的len个字符

4. void clear();//删除字符串中所有字符

void test6()
{
    string s1 = "123456789";


    // s1.erase(s1.begin()+1);              // 结果：13456789
    // s1.erase(s1.begin()+1,s1.end()-2);   // 结果：189
    s1.erase(1,6);                       // 结果：189
    string::iterator iter = s1.begin();
    while( iter != s1.end() )
    {
        cout<<*iter;
        *iter++;
    }
    cout<<endl;

}

string字符串的查找

1. size_t find (constchar* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s，返回找到的位置索引，

    -1表示查找不到子串

2. size_t find (charc, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找字符c，返回找到的位置索引，

    -1表示查找不到字符

3. size_t rfind (constchar* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找子串s，返回找到的位置索引，

    -1表示查找不到子串

4. size_t rfind (charc, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找字符c，返回找到的位置索引，-1表示查找不到字符

5. size_tfind_first_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s的字符，返回找到的位置索引，-1表示查找不到字符

6. size_tfind_first_not_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找第一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

7. size_t find_last_of(const char* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，查找最后一个位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

8. size_tfind_last_not_of (const char* s, size_t pos = npos) const;

 //在当前字符串的pos索引位置开始，查找最后一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到子串

void test8()
{
    string s("dog bird chicken bird cat");

    //字符串查找-----找到后返回首字母在字符串中的下标

    // 1. 查找一个字符串
    cout << s.find("chicken") << endl;        // 结果是：9

    // 2. 从下标为6开始找字符'i'，返回找到的第一个i的下标
    cout << s.find('i',6) << endl;            // 结果是：11

    // 3. 从字符串的末尾开始查找字符串，返回的还是首字母在字符串中的下标
    cout << s.rfind("chicken") << endl;       // 结果是：9

    // 4. 从字符串的末尾开始查找字符
    cout << s.rfind('i') << endl;             // 结果是：18-------因为是从末尾开始查找，所以返回第一次找到的字符

    // 5. 在该字符串中查找第一个属于字符串s的字符
    cout << s.find_first_of("13br98") << endl;  // 结果是：4---b

    // 6. 在该字符串中查找第一个不属于字符串s的字符------先匹配dog，然后bird匹配不到，所以打印4
    cout << s.find_first_not_of("hello dog 2006") << endl; // 结果是：4
    cout << s.find_first_not_of("dog bird 2006") << endl;  // 结果是：9

    // 7. 在该字符串最后中查找第一个属于字符串s的字符
    cout << s.find_last_of("13r98") << endl;               // 结果是：19

    // 8. 在该字符串最后中查找第一个不属于字符串s的字符------先匹配t--a---c，然后空格匹配不到，所以打印21
    cout << s.find_last_not_of("teac") << endl;            // 结果是：21

}

string字符串的替换

1. string& replace(size_t pos, size_t n, const char *s);//将当前字符串

从pos索引开始的n个字符，替换成字符串s

2. string& replace(size_t pos, size_t n, size_t n1, char c); //将当前字符串从pos索引开始的n个字符，替换成n1个字符c

3. string& replace(iterator i1, iterator i2, const char* s);//将当前字符串[i1,i2)区间中的字符串替换为字符串s

void test7()
{
    string s1("hello,world!");

    cout<<s1.size()<<endl;                     // 结果：12
    s1.replace(s1.size()-1,1,1,'.');           // 结果：hello,world.

    // 这里的6表示下标  5表示长度
    s1.replace(6,5,"girl");                    // 结果：hello,girl.
    // s1.begin(),s1.begin()+5 是左闭右开区间
    s1.replace(s1.begin(),s1.begin()+5,"boy"); // 结果：boy,girl.
    cout<<s1<<endl;
}

string字符串的遍历

void test6()
{
    string s1("abcdef"); // 调用一次构造函数

    // 方法一： 下标法

    for( int i = 0; i < s1.size() ; i++ )
    {
        cout<<s1[i];
    }
    cout<<endl;

    // 方法二：正向迭代器

    string::iterator iter = s1.begin();
    for( ; iter < s1.end() ; iter++)
    {
        cout<<*iter;
    }
    cout<<endl;

    // 方法三：反向迭代器
    string::reverse_iterator riter = s1.rbegin();
    for( ; riter < s1.rend() ; riter++)
    {
        cout<<*riter;
    }
    cout<<endl;
}

string字符串的拼接

//append() & + 操作符

void test5()
{
    // 方法一：append()
    string s1("abc");
    s1.append("def");
    cout<<"s1:"<<s1<<endl; // s1:abcdef

    // 方法二：+ 操作符
    string s2 = "abc";
    /*s2 += "def";*/
    string s3 = "def";
    s2 += s3.c_str();
    cout<<"s2:"<<s2<<endl; // s2:abcdef
}

排序

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

void test9()
{
    string s = "cdefba";
    sort(s.begin(),s.end());
    cout<<"s:"<<s<<endl;     // 结果：abcdef
}

分割

//strtok()
函数返回字符串str1中紧接“标记”的部分的指针, 字符串str2是作为标记的分隔符。如果分隔标记没有找到，函数返回NULL。为了将字符串转换成标记，第一次调用str1 指向作为标记的分隔符。之后所以的调用str1 都应为NULL
    
void test10()
{
    char str[] = "I,am,a,student; hello world!";

    const char *split = ",; !";//分隔符
    char *p2 = strtok(str,split);
    while( p2 != NULL )
    {
        cout<<p2<<endl;
        p2 = strtok(NULL,split);
    }
}
运行结果：
        I
        am
        a
        student
        hello
        world

    
    
char str[] = "now # is the time for all # good men to come to the # aid of their country";
char delims[] = "#";
char *result = NULL;
result = strtok( str, delims );
while( result != NULL ) {
    printf( "result is \"%s\"\n", result );
    result = strtok( NULL, delims );
}

运行结果：
    result is "now "
    result is " is the time for all "
    result is " good men to come to the "
    result is " aid of their country"

//substr
substr(size_type _Off = 0,size_type _Count = npos)

//substr()是C++语言函数，主要功能是复制子字符串，要求从指定位置开始，并具有指定的长度。如果没有指定长度_Count或_Count+_Off超出了源字符串的长度，则子字符串将延续到源字符串的结尾。
    
s.substr(); // 返回s的全部内容 
s.substr(11); // 从索引11往后的子串 
s.substr(5,6); // 从索引5开始6个字符


void test11()
{
    string s1("0123456789");
    string s2 = s1.substr(2,5); // 结果：23456-----参数5表示：截取的字符串的长度
    cout<<s2<<endl;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

甲乙zzu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值