c++ String 类函数详解

c++ String 类函数详解

总算抽出时间把string类里的函数好好研究一遍，在VS2013里完整运行了一遍，加深了一下理解：

代码块

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

void main()
{

    string s = "asdssfghjkl";
    char a1;
    string::iterator it;
    string::const_iterator cit;
    string::size_type n;

    s.append("zxcv");  //s="asdssfghjklzxcv",参数必须为string类型 不可为char。
    s.assign("qwert"); //s="qwert"，相当于赋值操作，赋以新值 ，参数不可为char。
    a1 = s.at(0);      //a1='q' 下标操作
    a1 = s.back();     //a1='t' 返回最后一个字符
    it = s.begin();    //返回字符串起始位置的迭代器，cit = s.begin(); 正确
    a1=it[0];          //s ="qwert"， a1='q'，a=cit[0]; 正确
    it[3] = 'f';       //s ="qweft"，cit[3] = 'f'; 错误

    n = s.capacity();       //s="qwert" n=15(win64 vs2013) 
    /* 给字符串分配内存的时候，并不是有多大长度分配多少的，考虑到append等操 作，一次分配内存是比给他的字符串长度多的。这样在append的时候，就不用 每次都分配内存了。除非append时，已分配内存不够了，会再次追加一次内存 分配。当前已经分配的内存大小，就是capacity。字符串实际大小，就是 size。这样做是为了提高字符串操作效率。capacity是容量，是可存放字符 的个数。size是大小，是当前已存放字符的个数。capacity >= size， 具 体capcacity大多少，具体的stl库实现决定。capacity是可增大的，如果当 前size加上要加入的字符个数超过capacity，capacity就要增大，一般翻倍 增长，具体取决于实现。 */

    cit=s.cbegin();    //s="qweft"，返回字符串起始位置的const型迭代器
    a1 = cit[1];       // a1='w'
    /* 1.iterator,const_iterator作用：遍历容器内的元素，并访问这些元素的 值。iterator可以改元素值,但const_iterator不可改。跟C的指针有点像 2.const_iterator 对象可以用于const vector 或非 const vector,它 自身的值可以改(可以指向其他元素),但不能改写其指向的元素值. 如 cit[1] = 'o' 错误 */

    cit = s.cend();   //cit = " "，返回字符串末尾的 const型迭代器
    s.clear();        //删除字符串里的所有字符

    s = "asdfg";
    int n1=s.compare("asdfg");     //n1=0 字符串比较
    int n2 = s.compare("sdfg");    //n1=-1
    int n3 = s.compare("ab");      //n1=1

    char* sdest;
    n=s.copy(sdest,1,0);    //会报unsafe的问题
    /* size_type copy( CharT* dest, size_type count, size_type pos = 0); 参数: dest pointer to the destination character string pos position of the first character to include count length of the substring 返回值: copy的字符个数 从string类型对象中至多复制count个字符到字符指针dest指向的空间中。默 认从首字符开始，但是也可以指定，开始的位置（记住从0开始）。返回真正从对 象中复制的字符。用户要确保p指向的空间足够保存n个字符。 */


    string::const_reverse_iterator it2; 
    it2=s.crbegin();  /*返回const翻转迭代器，将s先翻转，再取其begin。 it2[2] = 'g';错误。it2=" "，相当于取到s的最后一个元素 ++是往s的前 面取。*/

    a1 = it2[0];      //a1='g'
    a1 = it2[1];      //a1='f' 
    it2 = s.crend();  /*返回const翻转迭代器，将s先翻转，再取其end。 it2 = "asdfg"; char a3 = it2[0]; char a4 = it2[1]; 错误溢出。 相当于取到s的第一个元素前一个。与cbegin cend 相反。*/

    const char* s1;
    s1=s.c_str();   /*s1="asdgf"，c_str()返回的是一个临时指针，不能 对其进行操作，s中字符删除s1也就没了，s1是c字符串，末尾追加\0。*/
    /* const char* c; string s="1234"; c = s.c_str(); cout<<c<<endl; //输出：1234 s="abcd"; cout<<c<<endl; //输出：abcd c_str()返回一个客户程序可读不可改的指向字符数组的指针，不需要手动释放 或删除这个指针。*/

    s1=s.data();  /*s1="asdfg"，与c_str()类似，但是返回的数组不以空 字符终止。*/

    bool flag = s.empty();  //flag=false，返回bool型，为空返回true
    it=s.end();     //it=" "，返回迭代器指向s末尾。

    s.erase(2,2);   //s="asg"，从下标2开始删除2个，s = "asdfg";
    s.erase(s.begin(), s.begin() + 3);  //s="fg"，s = "asdfg";
    s.erase(4);   //s="asdf"，删除下标4的值，s = "asdfg";
    s.erase(s.begin() + 4);   //s="asdf"，删除下标4的值。
    s.erase(s.begin(), s.end());  //s=" "，s.end()是末尾元素下一个
    /* (1)erase(pos,n); 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符 （2）erase(position); 删除position处的一个字符(position是个string类型的迭代器) （3）erase(first,last); 删除从first到last之间的字符（first和last都是迭代器） 输入下标0，1，2...和迭代器s.begin(),s.begin()+1....A对应。 */



    s = "asdfg";
    n = s.find("asdfg");  //n=0 查找 全匹配 
    n=s.find(100);        //n=2，将100转为字符查找，d的ascii码为100 
    n=s.find('dfg');      //n=4 
    n = s.find("dfg");    //n=2 
    n=s.find("dhh");      //n=string::npos=4294967295
    n = s.find("wer");    //n=string::npos=4294967295
    n=s.find('f');        //n=3
    n = s.find("f");      //n=3
    char as = 'dfg';      //as='g'

    n = s.find_first_of("asdfg");  //n=0，查找包含子串中的任何字符， 返回第一个位置 
    n = s.find_first_of(3);        //n=string::npos=4294967295 
    n = s.find_first_of('dfg');    //n=4 
    n = s.find_first_of("dfg");    //n=2
    n = s.find_first_of("dhh");    //n=2 
    n = s.find_first_of("wer");    //n=string::npos=4294967295
    n = s.find_first_of('f');      //n=3，从pos开始查找字符第一次出现的位置
    n = s.find_first_of("f");      //n=3

    n = s.find_last_of("asdfg"); //n=4，查找包含子串中的任何字符，返回最后一个位置
    n = s.find_last_of(3);         //n=string::npos=4294967295 
    n = s.find_last_of('dfg');     //n=4 
    n = s.find_last_of("dfg");     //n=4
    n = s.find_last_of("dhh");     //n=2 
    n = s.find_last_of("wer");     //n=string::npos=4294967295
    n = s.find_last_of('f');       //n=3
    n = s.find_last_of("f");       //n=3

    n = s.find_first_not_of("asdfg");//n=string::npos=4294967295，查找不包含子串中的任何字符，返回第一个位置。从当前串中查找第一个不在参数串中的字符出现的位置
    n=s.find_first_not_of(3);      //n=0 
    n=s.find_first_not_of('dfg');  //n=0 
    n = s.find_first_not_of("dfg");//n=0
    n=s.find_first_not_of("dhh");  //n=0 
    n = s.find_first_not_of("wer");//n=0
    n=s.find_first_not_of('f');    //n=0
    n = s.find_first_not_of("f");  //n=0

    n = s.find_last_not_of("asdfg");//n=string::npos=4294967295，查找不包含子串中的任何字符，返回最后一个位置
    n=s.find_last_not_of(3);          //n=4 
    n=s.find_last_not_of('dfg');      //n=3 
    n = s.find_last_not_of("dfg");    //n=1
    n=s.find_last_not_of("dhh");      //n=4
    n = s.find_last_not_of("wer");    //n=4
    n=s.find_last_not_of('f');        //n=4
    n = s.find_last_not_of("f");      //n=4

    n = s.rfind("asdfg");  //n=0，反向查找，从pos开始从后向前查找字符c在当前串中的位置
    n=s.rfind(3);          //n=string::npos=4294967295 
    n=s.rfind('dfg');      //n=4 
    n = s.rfind("dfg");    //n=2
    n=s.rfind("dhh");      //n=string::npos=4294967295 
    n = s.rfind("wer");    //n=string::npos=4294967295
    n=s.rfind('f');        //n=3
    n = s.rfind("f");      //n=3

    /*以上查找函数都被重载了4次： size_type find(const basic_string& s, size_type pos = 0) //从pos开始查找字符串s在当前串中的位置 size_type find(const charT* s, size_type pos, size_type n) //从pos开始查找字符串s中前n个字符在当前串中的位置 size_type find(const charT* s, size_type pos = 0) //从pos开始查找字符串s在当前串中的位置 size_type find(charT c, size_type pos = 0) //从pos开始查找字符c在当前字符串的位置 所有的查找函数都返回一个size_type类型，这个返回值一般都是所找到字符串 的位置，如果没有找到，则返回string::npos。 有一点需要特别注意，所有和string::npos的比较一定要用 string::size_type来使用，不要直接使用int 或者unsigned int等类 型。其实string::npos表示的是-1。 */


    a1=s.front();//a1='a'，返回首字符，返回值为char/const char，不是string或迭代器
    string::allocator_type aa=s.get_allocator();  //返回本字符串的配置器

    s.insert(2,"z");              //s="aszdfg"
    s.insert(2, "qwegt", 3);      //s="asqwezdfg"。
    /*const string a1 = "zxc"; s.insert(2,a1); //错误*/
    s.insert(2, "zxcv", 2, 2);    //s="ascvqwezdfg"
    /* 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 */


    n = s.length();    //n=11,s="ascvqwezdfg",返回字符串长度。 
    n = s.max_size();  //s="ascvqwezdfg",n=4294967294,返回值是string所支持最大长度，一般也不会用到这么长的字符串。
    n=s.npos;  //n=4294967295

    string s11 = "qwe";
    string s22 = "asd"; 
    string ss = s11 + s22;    //ss=""qweasd""
    ss += "dfr";              //ss=""qweasddfr""
    //s11+=s22; //错误
    //s11 = s22; //错误 string 不能到const char*
    a1 = s[3];                //a1='v'

    s.pop_back();             //s="ascvqwezdf",删除最后一位

    a1 = 'm';
    s.push_back(a1);  //s=""ascvqwezdfm"" 参数为char型


    string::reverse_iterator rit;
    string::const_reverse_iterator crit;

    rit=s.rbegin(); //s="ascvqwezdfm"，末尾为start，开始为end，迭代器从后往前递增
    a1=rit[3];      //s="ascvqwezdfm" a1='z'
    rit[3] = 'n';   //rit="" s="ascvqwendfm" 从后往前下标为三的变成了n
    crit = s.rbegin();  //crit="" s="ascvqwendfm"
    a1 = crit[4];       //a1='e' s="ascvqwendfm"
    //crit[3] = 'n'; //错误 不能改变const迭代器指向的值


    rit = s.rend();     //s="ascvqwendfm" 末尾为start 开始为end rit=""
    //a1 = rit[3]; //报错 溢出
    // rit[3] = 'n'; //报错 溢出
    crit = s.rend();    //crit="" s="ascvqwendfm"
    //a1 = crit[4]; //报错 溢出
    //crit[3] = 'n'; //错误 不能改变const迭代器指向的值

    string s33 = "mnbvcx";      //s="ascvqwendfm"
    const char * s44= "asdfg";  //s="ascvqwendfm"
    s.replace(2,3,s33); //s="asmnbvcxwendfm"，替换原字符串下标2开始长度3的字符
    s.replace(2, 3, s44);       //s="asasdfgvcxwendfm"
    s.replace(s.begin()+2,s.end()-2, s33);     //s="asmnbvcxfm"
    s.replace(s.begin() + 2, s.end() - 2, s44);//s="asasdfgfm"
    s.replace(2, 3, s33, 2, 3);    //s="asbvcfgfm"
    s.replace(2, 3, s44, 2, 3);    // s="asdfgfgfm"
    s.replace(2, 3, s44, 2);       // s="asasfgfm"
    s.replace(s.begin() + 2, s.end() - 2, s44,4);  //s="asasdffm"
    s.replace(2, 3, 4, 'c'); //s="asccccffm"
    s.replace(s.begin() + 2, s.end() - 2, 4, 'f');  //s="asfffffm" 
    /* 用法一： 用str替换指定字符串从起始位置pos开始长度为len的字符 string& replace (size_t pos, size_t len, const string& str); 用法二： 用str替换 迭代器起始位置 和 结束位置 的字符 string& replace (const_iterator i1, const_iterator i2, const string& str); 用法三： 用substr的指定子串（给定起始位置和长度）替换从指定位置上的字符串 string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen); 用法四： string转char*时编译器可能会报出警告，不建议这样做，用str替换从指定 位置0开始长度为5的字符串。 string& replace(size_t pos, size_t len, const char* s); 用法五： string转char*时编译器可能会报出警告，不建议这样做，用str替换从指定 迭代器位置的字符串 string& replace (const_iterator i1, const_iterator i2, const char* s); 用法六： string转char*时编译器可能会报出警告，不建议这样做，用s的前n个字符 替换从开始位置pos长度为len的字符串 string& replace(size_t pos, size_t len, const char* s, size_t n); 用法七： string转char*时编译器可能会报出警告，不建议这样做，用s的前n个字符 替换指定迭代器位置(从i1到i2)的字符串 string& replace (const_iterator i1, const_iterator i2, const char* s, size_t n); 用法八： 用重复n次的c字符替换从指定位置pos长度为len的内容 string& replace (size_t pos, size_t len, size_t n, char c); 用法九： 用重复n次的c字符替换从指定迭代器位置（从i1开始到结束）的内容 string& replace (const_iterator i1, const_iterator i2, size_t n, char c); */


    n = s.size();     //n=8 s="asfffffm"
    s.reserve(2);  //指定 容器 能存储数据的个数
    s.resize(3);    //重新 指定 有效元素的个数 s="asf"
    n=s.size();     //n=3
    /* size() 指目前存在的元素数。 元素个数 capacity() 指容器能存储 数据的个数 容器容量 reserve() 指定容器能存储数据的个数 resize() 重新指定有效元素的个数 ，区别于reserve()指定容量的大小 当创建空容器时，容量(capacity)为 0;当用完时，增加原容量的 1/2 （各 编译器 可能存在差异 vs2010是这样的，mingw则 增加原容量 ）--适用如 vector这种 元素连续存储的容器， 如为list则不同。capacity 一般大于 size的原因是为了避免 每次增加数据时都要重新分配内存，所以一般会 生成一 个较大的空间，以便随后的数据插入。 */

    s = "asdfgh";
    n=s.rfind("sdf",2);         //n=1
    n = s.rfind("serr");        //n=4294967295
    n = s.rfind("serr",2);      //n=4294967295
    n = s.rfind('serr', 2);     //n=4294967295
    n = s.rfind('s', 2);        //n=1
    n = s.rfind('s');           //n=1
    n = s.rfind("serr", 2,3);   //n=4294967295
    n = s.rfind("sdf", 2,2);    //n=1

    /* rfind全名reversefind,与find相。 size_type rfind( const basic_string &str, size_type index ); //返回最后一个与str中的某个字符匹配的字符，从index开始查找。如果没找 到就返回string::npos。 size_type rfind( const char *str, size_type index ); //返回最后一个与str中的某个字符匹配的字符，从index开始查找。如果没找 到就返回string::npos。 size_type rfind( char ch, size_type index ); //返回最后一个与ch匹配的字符，从index开始查找。如果没找到就返回 string::npos。 这里要注意与find不同的地方，rfind是从左往右数index个位置，这里作为基 准index，然后从这里开始，从右往左数到第一次出现目标的位置。 find是在基准index从左往右数。 */


    s.shrink_to_fit();  //无返回值
    /* erase 改变了size，但并没有改变capacity，并未真正释放空间 clear后 size==0，capacity不变，并未真正释放空间。 vector<int>(vec).swap(vec) 使得vec的capacity()==size()，真正 释放了空间。 C++11中已经实现了shink_to_fit函数 替代swap，调用该请求可能会引起一 次内存重分配，但不会对size产生影响，使得capacity()==size()。 */



    ss = s.substr(3);    //s="asdfgh"，ss="fgh"，从s的下标3 的位置开始取到末尾 
    ss = s.substr(3,4);  //ss="fgh"
    ss = s.substr(1, 4); //ss="sdfg" 从下标1开始取4个
    /* basic_string substr( size_type index, size_type num = npos );下标非迭代器 substr()返回本字符串的一个子串，从index开始，长num个字符。 如果没有指定，将是默认值 string::npos。这样，substr()函数将简单的返 回从index开始的剩余的字符串。 */

    s.swap(s);  //s="asdfgh" 用来交换两个string的值 无返回值
    s.swap(ss); //s="sdfg" ss="asdfgh" 
    system("pause");
}