C++ String常用函数

一，类型别名

size_type

无符号整型

iterator

迭代器类型

const_iterator

只读迭代器

reverse_iterator

逆序迭代器

const_reverse_iterator

只读逆序迭代器

different_type

足以存储两个迭代器差值的有符号整型

value_type

元素类型

reference

元素左值类型，是value_type&的同义词

const_reference

元素常量左值类型，是const value_type&的同义词

---

---

二，构造函数

string s1;

默认构造函数

string s2(s1);

初始化为s1的副本

string s3(“value”);

初始化为字符串字面值的副本

string s4(n,‘c’);

初始化为n个字符为’c’的副本

string s5(cp,n);

初始化为cp所指数组的前n个字符的副本

string s6(s1,pos);

初始化为s1从下标pos开始的字符的副本

string s7(s1,pos,len);

初始化为s1从下标pos开始长度为len个字符的副本

string s8(b,e);

初始化为迭代器b和e标记范围内的元素的副本

实践操作

复制格式化复制

    
    
#include <iostream>
#include <string>
using namespace std;
 
int main ()
{
    string str ("12345678");
    char ch[ ] = "abcdefgh";
    string a; //定义一个空字符串
    string str_1 (str); //构造函数，全部复制
    string str_2 (str, 2, 5); //构造函数，从字符串str的第2个元素开始，复制5个元素，赋值给str_2
    string str_3 (ch, 5); //将字符串ch的前5个元素赋值给str_3
    string str_4 (5,'X'); //将 5 个 'X' 组成的字符串 "XXXXX" 赋值给 str_4
    string str_5 (str.begin(), str.end()); //复制字符串 str 的所有元素，并赋值给 str_5
    cout << str << endl;
    cout << a << endl ;
    cout << str_1 << endl;
    cout << str_2 << endl;
    cout << str_3 << endl;
    cout << str_4 << endl;
    cout << str_5 << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main ()
{
    string str ("12345678");
    char ch[ ] = "abcdefgh";
    string a; //定义一个空字符串
    string str_1 (str); //构造函数，全部复制
    string str_2 (str, 2, 5); //构造函数，从字符串str的第2个元素开始，复制5个元素，赋值给str_2
    string str_3 (ch, 5); //将字符串ch的前5个元素赋值给str_3
    string str_4 (5,'X'); //将 5 个 'X' 组成的字符串 "XXXXX" 赋值给 str_4
    string str_5 (str.begin(), str.end()); //复制字符串 str 的所有元素，并赋值给 str_5
    cout << str << endl;
    cout << a << endl ;
    cout << str_1 << endl;
    cout << str_2 << endl;
    cout << str_3 << endl;
    cout << str_4 << endl;
    cout << str_5 << endl;
    return 0;
}

---

---

三，添加元素

s.push_back(‘t’);

尾部添加值为t的字符

s.insert(p,‘t’);

迭代器p前面插入值为’t’的字符，返回指向新字符的迭代器

s.insert(p,n,‘t’);

迭代器p前插入n个值为’t’的字符，返回void

s.insert(p,b,e);

迭代器p前插入由迭代器b和e标记范围的元素

s.insert(pos,n,‘t’);

在下标pos前插入n个值为’t’的字符

s.insert(pos,s2);

在下标pos前插入string对象s2

s.insert(pos,s2,pos2,len);

在下标pos前插入s2从pos2下标开始的len个字符

s.insert(pos,cp,len);

在下表pos前插入cp所指数组的前len个字符

s.insert(pos,cp);

在下表pos前插入cp所指的以空字符结束的字符串

实践操作

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include<iostream> using namespace std; int main() {   string str= "hello" ;   string s= "Hahah" ;   str.insert(1,s); //在原串下标为1的字符e前插入字符串s   cout<<str<<endl;     string str1= "hello" ;   char c= 'w' ;   str1.insert(4,5,c); //在原串下标为4的字符o前插入5个字符c   cout<<str1<<endl;     string str2= "hello" ;   string s2= "weakhaha" ;   str2.insert(0,s2,1,3); //将字符串s2从下标为1的e开始数3个字符，分别是eak，插入原串的下标为0的字符h前   cout<<str2<<endl;     return 0; }

---

---

---

四，删除元素

---

erase（）删除

erase 方法原型：

1. basic_string & erase(size_type pos=0, size_type n=npos);

   即erase（pos，n）;从给定起始位置pos处开始删除, 删除n个字符, 返回值修改后的string对象引用。比如erase(0,1)就是删除第一个字符。

2. iterator erase(const_iterator position)
   即erase（positon），删除迭代器位置处的单个字符(position是个string类型的迭代器), 并返回下个元素的迭代器。

如果position 不是迭代器位置，则删除该位置及之后的所有字符。

3. iterator erase(const_iterator first, const_iterator last)
   即erase（first，last）；删除迭代器（first, last)区间的所有字符（first和last都是迭代器）,返回一个指向被删除的最后一个元素的下一个字符的迭代器.

---

s.erase§;

删除迭代器p所指向的元素。返回指向被删元素后一个元素的迭代器

s.erase(b,e);

删除由迭代器b和e标记范围内的元素，返回指向被删元素段后一个元素的迭代器

s.pop_back();

删除最后一个元素。返回void。VS2010支持。

s.clear();

删除所有元素，返回void

实践操作

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include<iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #include<string>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	string str = 
     
     "hello the world!";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	string str1 = 
     
     "hello the world!";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	string str2 = 
     
     "hello the world!";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	string str3 = 
     
     "hello the world!";
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	string str4 = 
     
     "hello the world!";
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     /****************第1种用法:earse(pos,n)**************************/
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	str.
     
     erase(
     
     6, 
     
     2);   
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	cout << 
     
     "<" << str << 
     
     ">" << endl;  
     
     // <hello e world!>    
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     /****************第2种用法:earse(position)***********************/
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	str1.
     
     erase(
     
     8);  
     
     //如果pos不是迭代器位置，则删除该位置及之后的所有字符
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	cout << 
     
     "<" << str1 << 
     
     ">" << endl;    
     
     //  <hello th>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	str2.
     
     erase(str2.
     
     begin()); 
     
     //如果pos是迭代器，则
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	cout << 
     
     "<" << str2 << 
     
     ">" << endl;    
     
     //  <ello the world!>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     /****************第3种用法:earse(fist,last)**********************/
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	str3.
     
     erase(str3.
     
     begin() + 
     
     3, str3.
     
     end()
     
     -3);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	cout << 
     
     "<" << str3 << 
     
     ">" << endl;     
     
     // <helld!>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	str4.
     
     erase(str4.
     
     begin() + 
     
     3, str4.
     
     end());
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	cout << 
     
     "<" << str4 << 
     
     ">" << endl;    
     
     //  <hel>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

---

---

五，长度大小

s.size();

返回s中元素个数，类型为size_type

s.max_size();

返回s中可容纳最多元素个数，类型为size_type

s.empty();

返回s中元素是否为0的布尔值

s.resize(n);

调整s的长度大小，使其能容纳n个元素

如果n<s.size(),则删除多余元素，否则，添加采用值初始化的新元素

s.resize(n,‘t’);

调整s的长度大小，使其能容纳n个值为’t’的元素

s.capacity();

返回在s需要分配更多存储空间前能存储的元素个数，返回类型为size_type

s.reserve(n);

设置s预留n个元素的存储空间，返回void

时间不多了，只做部分实践操作

1. #define _CRT_SECURE_NO_WARNINGS
2. #include "iostream"
3. #include "string"
4. using namespace std;
6. int main()
7. {
8. string str = "hello world";
9. int len = str. length();
11. cout<<len<<endl;
12. system( "pause");
13. return 0;
14. }

---

---

六，赋值操作

s1=s2;

删除s1的所有元素，将s2元素复制给s1

s1.swap(s2);

将s1和s2的内容交换

s.assign(b,e);

重设s的元素：将迭代器b和e标记范围的元素复制给s

s.assign(n,‘t’);

重设s为存储了n个值为’t’的对象

s.assign(s2);

不解析

s.assign(s2,pos2,len);

不解析

s.assign(cp,len);

不解析

s.assign(cp);

不解析

---

---

七，子串操作

s.substr(pos,n);

返回string类型字符串，包含从下表pos开始的n个字符

s.substr(pos);

不解析

s.substr();

返回s的副本

s.c_str();

返回s的c风格字符串

---

---

八，string对象修改

操作函数：（args在参数表定义）

s.append(args);

将args串接在s后面。返回s的引用

s.replace(pos,len,args);

删除s中从下标开始的len个字符，用args替代之。返回s的引用。

此版本中，args不能为b2,e2

s.replace(b,e,args);

删除迭代器b和e标记范围内所有的字符，用args替代之。返回s的引用。

此版本中，args不能为s2,pos2,len2

args参数定义：

s2

string 类型的字符串s2

s2,pos2,len2

string类型的字符串s2中从下标pos2开始的len2个字符

cp

指针cp指向的以空字符结束的数组

cp,len2

cp指向的数组中的前len2个字符

n,‘t’

字符’t’的n个副本

b2,e2

迭代器b2和e2标记范围内的所有字符

---

---

九，string查找操作

操作函数：（args在参数表格定义，返回类型都是size_type或是string::nops）

注意：find和rfind是串精确查找，而find_first和find_last是单个字符查找。

s.find(args);

在s中查找args的第一次出现

s.rfind(args);

在s中查找args的最后一次出现

s.find_first_of(args);

在s中查找args的任意字符的第一次出现

s.find_last_of(args);

在s中查找args的任意字符的最后一次出现

s.find_first_not_of(args);

在s中查找第一个不属于args的字符

s.find_last_not_of(args);

在s中查找最后一个不属于args的字符

agrs参数：

‘t’,pos

从下标pos开始，查找字符’t’，pos的默认值为0

s2,pos

从下标pos开始，查找string对象s2，pos默认值为0

cp,pos

查找cp所指C风格字符串，pos默认值为0

cp,pos,n

从下标pos开始，查找cp所指数组前n个字符

---

---

十，string对象比较(大于返回正数，小于返回负数，等于返回0）

s.compare(s2);

比较s和s2

s.compare(pos1,n1,s2);

让s中从pos下标开始的n1个字符跟s2做比较

s.compare(pos1,n1,s2,pos2,n2);

让s中从pos1下标开始的n1个字符与s2中从pos2开始的n2个字符比较

s.compare(cp);

cp，C风格字符串

s.compare(pos1,n1,cp);

不解析

s.compare(pos1,n1,cp,n2);

不解析