C++string类学习笔记

原本在C中我们是使用char *类型或者字符数组char a[]这样的来实现字符串的，但是在C++中有了string类，极大地方便了我们队字符串进行操作。今天就来详细的学习一番string类。
1、想要使用string类，首先需要在你的cpp文件中包含，即：

#include <string>并且需要using std::string或者using std::wstring或者直接using namespace std;

#include <iostream>

using namespace std;

int main()
{
    string s1 = "hello world!";                                               //重载=可以为string类赋值
    string s2;                                                                //默认构造函数

    int length = s1.length();                                                 //int length()const;
    length = s1.size();                                                       //int size()const;
    length = s1.capacity();                                                   //int capacity()const;
    length = s1.max_size();                                                   //int max_size()const;
    s1.resize(20, '*');                                                       //void resize(int n, char c);

    bool t = s2.empty();                                                      //bool empty()const;
    if(t)
    {
        cout<<"empty"<<endl;                                                  //默认构造函数是空字符串
    }
    else
    {
        cout<<"not empty"<<endl;
    }

    //从输入流获取字符串s,以换行符隔开,不读入换行符
    getline(cin, s2);                                                         //getline(istream &in, string &s);
    cout<<s2<<endl;

    string s3(s2);                                                            //将s2赋值给s3
    string s4(5, 'H');                                                        //用n(5)个字符c(H)给s4赋值
    char *s = "nice";
    string s5(s);                                                             //用C类型字符串给s5赋值
    string s6(s, 2);                                                          //用C类型字符串开始的n(2)个字符赋值(ni)
    string s7(s1);                                                            //将s1赋值给s7
    string s8(s1, 2, 5);                                                      //将s1中从第二个开始的n个字符赋值给s8

    //包括begin 和 end对应的字符
    string s9(s1.begin(), s1.end());                                          //将s1的begin到end之间字符全部赋值给s9

    s9 = s1 + s9;                                                             //＋用于连接字符串
    s8.append(s2);                                                            //将s2连接到s8的结尾
    s8.append(s, 2);                                                          //将C字符串s的前两个字符接到s8结尾

    //将s1从第n(2)个位置开始的k(5)个字符接到s8结尾
    s8.append(s1, 2, 5);            
    s8.append(6, 'H');                                                        //在s8的结尾添加n(6)个字符c(H)
    s8.append(s1.begin(), s1.end());                                          //将begin到end之间字符接到s8结尾

    if(s1 == s2) cout<<"equal"<<endl;                                         //'==''<=''>=''>''<'可以比较字符串大小

    //compare函数均为大于返回1小于返回-1，等于返回0
    int comp = s1.compare(s2);                                                //比较s2与s1的大小

    //比较从pos开始的n个字符组成的字符串s与当前字符串的大小
    int compare(int pos, int n,const string &s)const;

    //比较从pos开始的n个字符组成的字符串s与当前字符串从pos2开始的n2个字符串组成的字符串的大小
    int compare(int pos, int n,const string &s,int pos2,int n2)const;

    //string类的查找函数： 
    int find(char c, int pos = 0) const;                                      //从pos开始查找字符c在当前字符串的位置
    int find(const char *s, int pos = 0) const;                               //从pos开始查找字符串s在当前串中的位置

    //从pos开始查找字符串s中前n个字符在当前串中的位置
    int find(const char *s, int pos, int n) const;  
    int find(const string &s, int pos = 0) const;                             //从pos开始查找字符串s在当前串中的位置
    //查找成功时返回所在位置，失败返回string::npos的值 

    int rfind(char c, int pos = npos) const;                                  //从pos开始从后向前查找字符c在当前串中的位置
    int rfind(const char *s, int pos = npos) const;
    int rfind(const char *s, int pos = npos, int n) const;
    int rfind(const string &s,int pos = npos) const;
    //从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值 
    int find_first_of(char c, int pos = 0) const;                             //从pos开始查找字符c第一次出现的位置
    int find_first_of(const char *s, int pos = 0) const;
    int find_first_of(const char *s, int pos, int n) const;
    int find_first_of(const string &s,int pos = 0) const;
    //从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos 

    int find_first_not_of(char c, int pos = 0) const;
    int find_first_not_of(const char *s, int pos = 0) const;
    int find_first_not_of(const char *s, int pos,int n) const;
    int find_first_not_of(const string &s,int pos = 0) const;
    //从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos 

    int find_last_of(char c, int pos = npos) const;
    int find_last_of(const char *s, int pos = npos) const;
    int find_last_of(const char *s, int pos, int n = npos) const;
    int find_last_of(const string &s,int pos = npos) const; 
    int find_last_not_of(char c, int pos = npos) const;
    int find_last_not_of(const char *s, int pos = npos) const;
    int find_last_not_of(const char *s, int pos, int n) const;
    int find_last_not_of(const string &s,int pos = npos) const;
    //find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

    //string类的替换函数： 
    string &replace(int p0, int n0,const char *s);                            //删除从p0开始的n0个字符，然后在p0处插入串s
    string &replace(int p0, int n0,const char *s, int n);                     //删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
    string &replace(int p0, int n0,const string &s);                          //删除从p0开始的n0个字符，然后在p0处插入串s
    string &replace(int p0, int n0,const string &s, int pos, int n);          //删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
    string &replace(int p0, int n0,int n, char c);                            //删除p0开始的n0个字符，然后在p0处插入n个字符c
    string &replace(iterator first0, iterator last0,const char *s);           //把[first0，last0）之间的部分替换为字符串s
    string &replace(iterator first0, iterator last0,const char *s, int n);    //把[first0，last0）之间的部分替换为s的前n个字符
    string &replace(iterator first0, iterator last0,const string &s);         //把[first0，last0）之间的部分替换为串s
    string &replace(iterator first0, iterator last0,int n, char c);           //把[first0，last0）之间的部分替换为n个字符c
    string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串

    //string类的插入函数： 
    string &insert(int p0, const char *s);
    string &insert(int p0, const char *s, int n);
    string &insert(int p0,const string &s);
    string &insert(int p0,const string &s, int pos, int n);
    //前4个函数在p0位置插入字符串s中pos开始的前n个字符

    string &insert(int p0, int n, char c);                                    //此函数在p0处插入n个字符c
    iterator insert(iterator it, char c);                                     //在it处插入字符c，返回插入后迭代器的位置
    void insert(iterator it, const_iterator first, const_iterator last);      //在it处插入[first，last）之间的字符
    void insert(iterator it, int n, char c);                                  //在it处插入n个字符c

    //string类的删除函数 
    iterator erase(iterator first, iterator last);                            //删除[first，last）之间的所有字符，返回删除后迭代器的位置
    iterator erase(iterator it);                                              //删除it指向的字符，返回删除后迭代器的位置
    string &erase(int pos = 0, int n = npos);                                 //删除pos开始的n个字符，返回修改后的字符串

    //string类的迭代器处理： 
    //string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。
    //用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：
    const_iterator begin()const;
    iterator begin();                                                         //返回string的起始位置
    const_iterator end()const;
    iterator end();                                                           //返回string的最后一个字符后面的位置
    const_iterator rbegin()const;
    iterator rbegin();                                                        //返回string的最后一个字符的位置
    const_iterator rend()const;
    iterator rend();                                                          //返回string第一个字符位置的前面

    return 0;
}