string的各种函数（系统学习）

1、按照面向对象的要求，可以把字符串看作一个对象，设计一个串类加以描述。但是，在一般的情况下不必建立自己的串类，c++标准

在库<string>中给出了类string,提供了丰富的串操作，程序员使用指令: #include<string>即存取这个类。可将类string视为一个容器类，其部分操作如下：

构造函数：

string s:构造一个空串s

string s(a):构造串s,并用字符数组a初始化

string s(a,n):构造串s,用字符数组a的前n个字符初始化

string s(str):用串str构造串s(拷贝初始化）

看下面代码验证

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    char a[maxn];
    cin>>a;//输入abcdefgh
    string s(a);//结果为abcdefgh
    string s1(a,5);//结果为abcde
    string s2(s1);//结果为abcde
    cout<<s<<endl;
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

输入输出：

getline(cin,s,delim):从cin中提取字符存入串s中，当遇到delim或者提取的字符个数等于s的长度时结束，如果自己不设定，默认为' '

getline(cin,s):遇到' '结束

cin>>s:遇到空白字符终止提取，空白字符不被读取

cout<<s:输出s

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s;
    while(getline(cin,s,'#'))
    {
        getchar();//自己指定了字符要加getchar,不然结果会多出一个换行，但是默认情况下不用加getchar
        cout<<s<<endl;
    }
    return 0;
}

操作符：

s=val:赋值操作，val可以是一个串 ，一个字符或一个字符数组

s+=val:将val添加到串s之后

s[pos]:下标操作

s+t,t+s:s和t的连接，返回连接的结果。 t可以是一个串，一个字符或者一个字符数组

t<s,s<t,s<=t:由关系操作符确定结果是true还是false

t==s,s==t,s!+t······

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    char a;
    for(int i=0;i<5;i++)
    {
        cin>>a;
        s1+=a;
    }
    cout<<s1<<endl;//输入为abcde,结果为abcde
    cin>>s2;//输入fg
    cout<<s2<<endl;//输出fg
    s1+=s2;
    cout<<s1<<endl;//输出abcdefg
    if(s1<s2) cout<<"yes"<<endl;
    else cout<<"no"<<endl;
    return 0;
}

添加：

s.append(str):将str添加在s之后，返回s

s.append(str,pos,n):将str中从位置pos开始的n个字符添加在s之后，如果n太大，则取str中从位置pos到串结尾的字符，返回s

s.append(a):将字符数组添加在s之后，返回s

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;//输入abcde fg
    cout<<s1<<" "<<s2<<endl;//输出abcde fg
    s1.append(s2);
    cout<<s1<<endl;//输出abcdefg
    s2.append(s1,1,3);//输出结果为fgbcd
    cout<<s2<<endl;
    return 0;
}

赋值：

s.assign(str):用str给s赋值，返回s

s.assign(str,pos,n):将str中从位置pos开始的n个字符组成的字串赋给s

s.assign(a):将字符数组赋给s

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1;//输入abcde
    s2.assign(s1);
    cout<<s2<<endl;//输出结果为abcde
    s2.assign(s1,0,3);
    cout<<s2<<endl;//输出结果为abc
    return 0;
}

长度：

s.size():返回s的长度，不能用于统计C风格的以''结尾的字符串长度

s.length():返回s的长度，不能用于统计C风格的以''结尾的字符串长度

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1;//输入abcde
    cout<<s1.length()<<endl;
    cout<<s1.size()<<endl;
    return 0;
}

比较：
s.compare(str):根据s小于，等于，大于，返回一个负值，0，正值

s.compare(a):像上面的一样，只是这里是一个字符数组a而已

s.compare(pos,n,str):s中从位置pos开始的n个字符组成的子串与str比较

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;
    cout<<s1.compare(s2)<<endl;
    cout<<s1.compare(2,1,s2)<<endl;
    return 0;
}

插入：

s.insert(pos,str):在s的位置pos处插入str

s.insert(pos1,str,pos2,n):将str中从位置pos2开始的n个字符插入s中的位置pos1处

s.insert(pos,a,n):将a 的前n个字符插入s中位置pos处

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;//输入abcde
    s1.insert(0,s2);
    cout<<s1<<endl;
    s1.insert(0,s2,1,1);//位置都是从0开始的
    cout<<s1<<endl;
    return 0;
}

替换：

s.replace(pos1,n1,str):用str替换s中从位置pos1开始的n1个字符组成的子串，返回s

s.replace(pos1,n1,str,pos2,n2):用str中从位置pos2开始的n2个字符替换s中从位置pos1开始的n1个字符，返回s

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;//输入abcde fg
    s1.replace(1,2,s2);//结果为afgde
    cout<<s1<<endl;
    s1.replace(0,3,s2,0,2);
    cout<<s1<<endl;//结果为fgde
    return 0;
}

取子串：

s.substr(pos,n):返回从pos开始的n个字符组成的子串，如果n太大或者省略，则返回从pos开始直到s结尾的左右字符组成的子串，pos的默认值为0,会在末尾自动加''

c语言的strncpy函数不会在末尾帮你加''，切记要自己加

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1;//输入abcde
    cout<<s1.substr(1,3)<<endl;//结果为bcd
    return 0;
}

是否为空串：

s.empty:为空，返回true,不为空，返回false

查找：

s.find(str,pos):在串s中从位置pos开始查找串str,若查找成功，返回str首次出现的位置，若查找不成功，返回s.npos，pos的默认值为0

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    string s="abc";
    if(s.find('d')!=s.npos) cout<<"1"<<endl;
    else cout<<"0"<<endl;
    return 0;
}
//输出为0

s.find(a,pos):同上

s.rfind(str,pos):在s的前(pos+str.size())个字符中查找str,若查找成功，返回str最后一次出现的位置，若不成功，返回-1，若pos省略，则在s中查找str最后一次出现的位置

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;//输入abcde bc

        cout<<s1.find(s2,1);
    return 0;
}

#include<iostream>
#include<string.h>
#include<map>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<ctype.h>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxk=3e5+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
#define Lson l,mid,rt<<1
#define Rson mid+1,r,rt<<1|1
int main()
{

    string s1,s2;
    cin>>s1>>s2;//输入abcdefgabcdefg fg
    cout<<s1.rfind(s2)<<endl;//12
    cout<<s1.rfind(s2,8)<<endl;//5
    return 0;
}

reverce()函数：将字符串翻转，s.reverce(s.begin(),s.end())

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

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

int main()
{
    string s = "hello";

    reverse(s.begin(),s.end());

    cout<<s<<endl;

    return 0;
}

C++的string类提供下列3个成员函数将一个string类的对象s转换成C风格的字符串：

s.c_str():将存储在s中的字符作为字符数组返回，并添加一个空字符('')作为结束符

s.data():将存储在s中的字符作为字符数组返回，最后不添加('')

s.copy(a,n,pos):用s中从位置pos开始的n个字符替换a的前n个字符（如果n太大，则用从pos开始的n个字符直到s的末尾的所有字符），pos默认为0，返回用于替换的字符个数