stl string 容器的使用

string 是基本的字符串序列容器,对应数据结构中的串，和vector<char>也类似，但功能更多

string 容器的使用

　　1，string 的构造函数是。　　string()

　　2，string的添加函数,。  　　insert(),push_back()

　　3，string的遍历。    　　　 数组形式遍历，迭代器形式遍历

　　4，string的字符串替换　　  replace()

　　5，string 的字符搜索　　　 find()

　　6，其他的常见函数　　　　 size(),length(),empty()

#include<iostream>
using namespace std;
#include<string>
void test1();//测试string的构造函数
void test2();////测试字符添加函数
void testPrint();//测试string的遍历
void testErase();//测试string的字符删除
void testReplace();//测试string的字符串替换
void testFind();//测试字符搜索函数
void testOthers();//测试其他常见函数
void print1(string &s);//使用数组形式遍历,和vector,数组的遍历非常相似
void print2(string &s);//使用正向迭代器iterator遍历
void print3(string &s);//使用反向迭代器reverse_iterator遍历
int main(void)
{
    test1();
    test2();
    testPrint();
    testErase();
    testReplace();
    testFind();
    testOthers();
    getchar();
}
void test1()//测试string的构造函数
{
    /*
    string的构造函数
    string();//创建空的string对象
    string(const char *p);//使用字符串p，构造一个srring 对象
    string(const string &s);//由一个string对象s，构造一个新的string对象。
    string(const string &s，size_type=0,size_type n=npos);//将string对象s的[pos,pos+n)拷贝到新建的对象中
    */
    cout<<"-------测试string的构造函数--------------------"<<endl;
    char *p="I love Shanghai";

    string s1;//1.创建空的string对象s;
    s1=p;//将字符串p赋值给s1
    string s2(p);//将字符串数组p拷贝到新建的对象s2中
    string s3(s2);//使用一个对象s2创建一个新的对象s3
    string s4(s3,0,6);//使用string对象s3的[0,6)个字符创建新的string对象s4

    cout<<"对象s1:"<<s1<<endl;
    cout<<"对象s2:"<<s2<<endl;
    cout<<"对象s3:"<<s3<<endl;
    cout<<"对象s4:"<<s4<<endl;
    
}
void test2()//测试字符添加函数
{
    /*
    void push_back(char c) //在string对象的尾部添加字符c
    string & append(const char *s)//在string对象的尾部加字符串s
    string & append(const string &s)//在string对象的尾部加s对象的字符串
    itertor insert(iterator pos,const char &c)//在string对象 pos之前插入字符c
    string 还重载运算符+，+=
    */
    cout<<"---------测试字符添加函数------------------"<<endl;
    string str1;
    str1.push_back('a');
    str1.push_back('b');
    cout<<"str1:"<<str1<<endl;
    char *p="cdef";
    string str2(p);
    cout<<"str2:"<<str2<<endl;
    str1.append(str2);
    cout<<"append str2后str1："<<str1<<endl;
    str1.insert(str1.begin()+3,'8');//在str1[3]字符之前加字符8
    cout<<"insert后，str1："<<str1<<endl;
    string str3;
    str3=str1+str2;
    cout<<"s3=s1+s2:"<<str3<<endl;

}
void print1(string &s)//使用数组形式遍历,和vector,数组的遍历非常相似
{
    cout<<"使用数组形式遍历:";
    for(int i=0;i<s.size();i++)
    {
        cout<<s[i];
    }
    cout<<endl;
}
void print2(string &s)//使用正向迭代器iterator遍历
{
    cout<<"使用正向迭代器iterator遍历:";
    string::iterator i;
    for(i=s.begin();i<s.end();i++)
    {
        cout<<*i;//迭代器只能用*号，不像指针一样可以用数组形式s[i]
    }
    cout<<endl;
}
void print3(string &s)//使用反向迭代器reverse_iterator遍历
{
    cout<<"使用反向迭代器reverse_iterator反向遍历：";
    string::reverse_iterator i;
    for(i=s.rbegin();i<s.rend();i++)
    {
        cout<<*i;
    }
    cout<<endl;
}
void testPrint()//测试string的遍历
{
    cout<<"-------测试string的遍历-----------------"<<endl;
    char *p="I Love China!";
    string s(p);
    cout<<"string对象s:"<<s<<endl;
    print1(s);
    print2(s);
    print3(s);
}
void testErase()//测试字符的删除函数
{
    /*
    erase函数的原型如下：
    （1）string& erase ( size_type pos = 0, size_type n = npos );//从本质上来说，是一个整型数。关键是由于机器的环境，它的长度有可能不同。
    （2）iterator erase ( iterator position );
    （3）iterator erase ( iterator first, iterator last );
    也就是说有三种用法：
    （1）erase(pos,n); 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符
    （2）erase(position);删除position处的一个字符(position是个string类型的迭代器)
    （3）erase(first,last);删除从first到last之间的字符（first和last都是迭代器），[first,last)
    */
    cout<<"-------测试string的字符删除-----------------"<<endl;
    char *p="123456789";
    string s(p);
    cout<<"s:"<<s<<endl;
    
    s.erase(2,4);//删除s[2]开始的4个字符
    cout<<"s:"<<s<<endl;

    s.erase(s.begin());//删除迭代器s.bengin()处的字符
    cout<<"s:"<<s<<endl;

    s.erase(s.begin(),s.begin()+2);//删除bengin到begin+1之前的字符【begin,begin+2)
    cout<<"s:"<<s<<endl;

    s.clear();//清楚所有字符
    cout<<"s:"<<s<<endl;
}
void testReplace()//测试string的字符串替换
{
    /*
    string & replace(size_type pos,size_type n,const char*s)//将pos开始的n个字符，替换为字符串s;
    string & replace(size_type pos,size_type n,int m,char c )//将pos开始的n个字符，替换为m个字符c
    string & replace(iterator first,iterator last,const char *s)//将当前字符串的[first,last)替换为字符串s
    */
    cout<<"-----------测试string的字符串替换--------------"<<endl;
    char *p="Hello,boy!";
    string s(p);
    cout<<"s: "<<s<<endl;

    s.replace(6,3,"girls");//将s[6]开始的3个字符，替换为字符串girls;
    cout<<"s: "<<s<<endl;

    s.replace(11,1,2,'!');//将s[11]开始的1个字符，替换为2个字符'!'
    cout<<"s: "<<s<<endl;

    s.replace(s.begin(),s.begin()+5,"I Love");//将begin到.begin+5之间的字符替换为“I Love”
    cout<<"s: "<<s<<endl;
}
void testFind()//测试字符搜索函数
{
    /*
    size_type find(const char *s,size_type pos=0);//在当前字符串的pos位置开始，查找子串s,找到返回索引，没找到返回-1
    size_type find(const char c,size_type pos=0);//在当前字符串的pos位置开始，查找字符c的位置,找到返回索引，没找到返回-1
    size_type rfind(const char *s,size_type rpos=0);//在当前字符串的pos位置开始，反向查找子串s,找到返回索引，没找到返回-1
    size_type find_first_of(const char *s,size_type rpos=0);//在当前字符串的pos位置开始，查找位于子串的字符,找到返回索引，没找到返回-1
    size_type find_not_first_of(const char *s,size_type rpos=0);//在当前字符串的pos位置开始，查找第一个不位于子串的字符,找到返回索引，没找到返回-1
    */
    cout<<"------测试字符搜索函数---------------"<<endl;
    string s("dog bird chicken bird cat dog");
    for(int i=0;i<s.size();i++)
    {
        cout<<"s["<<i<<"]="<<s[i]<<"  ";
    }
    cout<<endl;

    cout<<"s: "<<s<<endl;
    //字符串查找
    cout<<s.find("bird")<<endl;
    cout<<(int)s.find("pig")<<endl;//返回的类型是size_type. size_type从本质上来说，是一个整型数。关键是由于机器的环境，它的长度有可能不同。
    //字符查找
    cout<<s.find('i',7)<<endl;//从s[7]开始找字符i,找到返回pos
    //c从字符串末尾开始查找字符串和字符
    cout<<s.rfind("bird")<<endl;
    cout<<s.rfind('i')<<endl;
    cout<<s.find_first_of("12dog34")<<endl;//s中的字符d第一个出现在“12dog34”返回0
    cout<<s.find_first_not_of("d34")<<endl;//s中的字符o是第一个没有出现在字符“d34”，返回1
    cout<<s.find_last_of("12dog34")<<endl;//s中的字符d,最后出现在“12dog34”的下标是28 ，返回28
    cout<<s.find_last_not_of("d34")<<endl;//s中最后一个不位于“d34”的字符g,下标是28
}
void testOthers()//其他常见函数
{
    cout<<"-----------测试其他常见函数---------------"<<endl;
    string s1;
    string s2;
    cout<<s1.empty()<<endl;//空返回1
    cout<<s1.compare(s2)<<endl;//两个字符串对象都为空，相等返回0
    s1+="123456789";
    cout<<s1.compare(s2)<<endl;//两个字符串对象不相等，返回1
    cout<<s1.compare("123456789")<<endl;//对象s1的字符串和“123456789”相等，返回0
    cout<<s1.empty()<<endl;//不为空返回0

    cout<<"s1.size="<<s1.size()<<endl;//s1的有9个字符，返回9
    cout<<"s1.length="<<s1.length()<<endl;//s1.length()放回9
    cout<<"s1.capacity="<<s1.capacity()<<endl;

    const char *cArray=s1.c_str();//转化为常量 字符数组
    cout<<cArray[5]<<endl;
}

void testSubstr()
{
     string a = "0123456789abcdefghij";
     cout<<a<<endl;
     string sub1 = a.substr(10);//从a[10]开始，全部
     cout << sub1 << '
';

     string sub2 = a.substr(5, 3);//从a[5]开始，长度为3
     cout << sub2 << '
';
     string sub3 = a.substr(12, 100);//从a[12]开始，长度为100
     cout << sub3 << '
';
}