STL——字符串用法详解

原文链接: https://yq.aliyun.com/articles/232724

      字符串是程序设计中最复杂的变成内容之一。STL string类提供了强大的功能,使得许多繁琐的编程内容用简单的语句就可完成。string字符串类减少了C语言编程中三种最常见且最具破坏性的错误:超越数组边界;通过违背初始化或被赋以错误值的指针来访问数组元素;以及在释放了某一数组原先所分配的存储单元后仍保留了“悬挂”指针。

string类的函数主要有:

    

Member functions
(constructor)
Construct string object  (public member function )
(destructor)
String destructor  (public member function )
operator=
String assignment  (public member function )


Iterators:
begin
Return iterator to beginning  (public member function )
end
Return iterator to end  (public member function )
rbegin
Return reverse iterator to reverse beginning  (public member function )
rend
Return reverse iterator to reverse end  (public member function )
cbegin 
Return const_iterator to beginning  (public member function )
cend 
Return const_iterator to end  (public member function )
crbegin 
Return const_reverse_iterator to reverse beginning  (public member function )
crend 
Return const_reverse_iterator to reverse end  (public member function )

Capacity:
size
Return length of string  (public member function )
length
Return length of string  (public member function )
max_size
Return maximum size of string  (public member function )
resize
Resize string  (public member function )
capacity
Return size of allocated storage  (public member function )
reserve
Request a change in capacity  (public member function )
clear
Clear string  (public member function )
empty
Test if string is empty  (public member function )
shrink_to_fit 
Shrink to fit  (public member function )

Element access:
operator[]
Get character of string  (public member function )
at
Get character in string  (public member function )
back 
Access last character  (public member function )
front 
Access first character  (public member function )

Modifiers:

operator+=
Append to string  (public member function )
append
Append to string  (public member function )
push_back
Append character to string  (public member function )
assign
Assign content to string  (public member function )
insert
Insert into string  (public member function )
erase
Erase characters from string  (public member function )
replace
Replace portion of string  (public member function )
swap
Swap string values  (public member function )
pop_back 
Delete last character  (public member function )

String operations:
c_str
Get C string equivalent  (public member function )
data
Get string data  (public member function )
get_allocator
Get allocator  (public member function )
copy
Copy sequence of characters from string  (public member function )
find
Find content in string  (public member function )
rfind
Find last occurrence of content in string  (public member function )
find_first_of
Find character in string  (public member function )
find_last_of
Find character in string from the end  (public member function )
find_first_not_of
Find absence of character in string  (public member function )
find_last_not_of
Find non-matching character in string from the end  (public member function )
substr
Generate substring  (public member function )
compare
Compare strings  (public member function )

Member constants
npos
Maximum value for size_t  (public static member constant )

Non-member functions overloads
operator+
Concatenate strings  (function )
relational operators
Relational operators for string  (function )
swap
Exchanges the values of two strings  (function )
operator>>
Extract string from stream  (function )
operator<<
Insert string into stream  (function )
getline
Get line from stream into string  (function )

C++string类常用函数
string类的构造函数:
string(const char *s);    //用c字符串s初始化
string(int n,char c);     //用n个字符c初始化
此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常


string类的字符操作:
const char &operator[](int n)const;
const char &at(int n)const;
char &operator[](int n);
char &at(int n);
operator[]和at()均返回当前字符串中第n个字符的位置,但at函数提供范围检查,当越界时会抛出out_of_range异常,下标运算符[]不提供检查访问。
const char *data()const;//返回一个非null终止的c字符数组
const char *c_str()const;//返回一个以null终止的c字符串
int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中,返回实际拷贝的数目


string的特性描述:
int capacity()const;    //返回当前容量(即string中不必增加内存即可存放的元素个数)
int max_size()const;    //返回string对象中可存放的最大字符串的长度
int size()const;        //返回当前字符串的大小
int length()const;       //返回当前字符串的长度
bool empty()const;        //当前字符串是否为空
void resize(int len,char c);//把字符串当前大小置为len,并用字符c填充不足的部分


string类的输入输出操作:
string类重载运算符operator>>用于输入,同样重载运算符operator<<用于输出操作。
函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中,以换行符'\n'分开。
 


string的赋值:
string &operator=(const string &s);//把字符串s赋给当前字符串
string &assign(const char *s);//用c类型字符串s赋值
string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值
string &assign(const string &s);//把字符串s赋给当前字符串
string &assign(int n,char c);//用n个字符c赋值给当前字符串
string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串
string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串
 


string的连接:
string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾 
string &append(const char *s);            //把c类型字符串s连接到当前字符串结尾
string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
string &append(const string &s);    //同operator+=()
string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string &append(int n,char c);        //在当前字符串结尾添加n个字符c
string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾 
 


string的比较:
bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较;
int compare(const string &s) const;//比较当前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函数在>时返回1,<时返回-1,==时返回0  


string的子串:
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串




string的交换:
void swap(string &s2);    //交换当前字符串与s2的值




string类的查找函数:


int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
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, int n = npos) 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第一个字符位置的前面
rbegin和rend用于从后向前的迭代访问,通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

字符串流处理:


通过定义ostringstream和istringstream变量实现,头文件中
例如:
    string input("hello,this is a test");
    istringstream is(input);
    string s1,s2,s3,s4;
    is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"
    ostringstream os;
    os<

    cout<


已知类String的原型为:

  class String
  {
  public:
  String(const char *str = NULL);// 普通构造函数
  String(const String &other); //  拷贝构造函数
  ~ String(void); // 析构函数
  String & operator =(const String &other);// 赋值函数
  private:
  char *m_data;// 用于保存字符串
  };
  请编写String的上述4个函数。
  //普通构造函数
  String::String(const char *str)
  {
  if(str==NULL)
  {
  m_data = new char[1]; // 对空字符串自动申请存放结束标志'\0'的//加分点:对m_data加NULL 判断
  *m_data = '\0';
  }
  else
  {
  int length = strlen(str);
  m_data = new char[length+1]; // 若能加 NULL 判断则更好
  strcpy(m_data, str);
  }
  }
  // String的析构函数
  String::~String(void)
  {
  delete [] m_data; // 或delete m_data;
  }
  //拷贝构造函数
  String::String(const String &other) // 输入参数为const型
  {
  int length = strlen(other.m_data);
  m_data = new char[length+1]; //对m_data加NULL 判断
  strcpy(m_data, other.m_data);
  }
  //赋值函数
  String & String::operator =(const String &other) // 输入参数为const
  型
  {
  if(this == &other) //检查自赋值
  return *this;
  delete [] m_data; //释放原有的内存资源
  int length = strlen( other.m_data );
  m_data = new char[length+1]; //对m_data加NULL 判断
  strcpy( m_data, other.m_data );
  return *this; //返回本对象的引用
  }
  剖析:
  能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上!在这个类中包括了指针类成员变量m_data,当类中包括指针类成员变量时,一定要重载其拷贝构造函数、赋值函数和析构函数,这既是对C++程序员的基本要求,也是《Effective C++》中特别强调的条款。仔细学习这个类,特别注意加注释的得分点和加分点的意义,这样就具备了60%以上的C++基本功!

1.string对象的定义和初始化

    初始化string对象的几种方式有:
  1. string s1;//默认构造函数,s1为空串
  2. string s2(s1);//将s2初始化为s1的一个副本
  3. string s3("value");//将s3初始化为value
  4. string s4(n,'c');//将s4初始化为字符'c'的n个副本
  5. string s5(s4,0,3)//从s4中下标为0的字符开始,连续取3个字符构成s5
  6. string s6 = s5 + "value";//value 接在s5后面,注意+操作符的左右操作数至少有一个是string类型的
  7. 迭代器创建,    由于可将string看作字符的容器对象,因此可以给string类的构造函数传递两个迭代器,将它们之间的数据复制到心的string对象中。
[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     string s1("How are you");  
  10.     string s2(s1.begin(),s1.end());  
  11.     string s3(s1.begin()+4,s1.begin()+7);  
  12.     cout<
  13.     cout<
  14.     cout<
  15.     return 0;  
  16. }  


2.string 对象的读写

    string对象的读写可以通过两个方式:
  1. 通过cin从标准输入中读取,cin忽略开题所有的空白字符,读取字符直至再次遇到空白字符,读取终止。
  2. 用getline读取整行文本,getline函数接受两个参数:一个输入流对象和一个string对象。getline函数从输入流的下一行读取,并保存读取的内容到string中,但不包括换行符。和输入操作符不一样的是,getline并不忽略开头的换行符。即便它是输入的第一个字符,getline也将停止读入并返回。如果第一个字符就是换行符,则string参数将被置为空string。

3.string对象的插入操作

    字符串一般通过包括首字符前、尾字符后、任意位置插入等几种情况。
    
[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     string s1("do");  
  10.     cout<<"Initial size is:"<
  11.     s1.insert(0,"How ");  
  12.     s1.append(" you");  
  13.     s1 = s1 + " do ?";  
  14.     cout<<"Final size is:"<
  15.     cout<
  16.     return 0;  
  17. }  
程序运行结果如下:

通过该函数可以得出:
  1.     insert函数,第一个参数表明插入源串的位置,第二个参数表面要插入的字符串,因此利用该函数可以实现串首、串尾及任意位置处的字符串插入功能。
  2. append函数,仅有一个输入参数,在源字符串尾部追加该字符串。
  3. 利用+实现字符串的连接,从而创建新的字符串。

4.替换操作

    常用的是replace函数,有三个输入参数:第一个用于指示从字符串的什么位置开始改写,第二个用于指示从源字符串中删除多少个字符,第三个是替换字符串的值。
    
[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     string s1("I love you forever !");  
  10.     cout<<"替换前:"<
  11.     s1.replace(7,3,"dachun");  
  12.     cout<<"替换后"<
  13.       
  14.     return 0;  
  15. }  
程序运行结果如下:


5.查询操作

    查询常用的函数有:
  1.     string::npos:这是string类中的一个成员变量,一般应用在判断系统查询函数的返回值上,若等于该值,表明没有符合查询条件的结果值。
  2. find函数:在一个字符串中查找指定的单个字符或字符组。如果找到,就返回首次匹配的开始位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
  3. find_first_of函数:在一个字符串中进行查找,返回值是第一个与指定字符串中任何字符匹配的字符位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
  4. find_last_of函数:在一个字符串中进行查找,返回值是最后一个与指定字符串中任何字符匹配的字符位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
  5. find_first_not_of函数:在一个字符串中进行查找,返回值是第一个与指定字符串中任何字符都不匹配的字符位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
  6. find_last_not_of函数:在一个字符串中进行查找,返回下标值最大的与指定字符串中任何字符都不匹配的字符位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
  7. rfind函数:对一个串从尾至头查找指定的单个字符或字符组,如果找到,就返回首次匹配的开始位置;如果没有找到匹配的内容,则返回string::npos。一般有两个输入参数,一个是待查询的字符串,一个是查询的起始位置,默认起始位置为0.
[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     string s1("what's your name? my name is TOM. How do you do? Fine,thanks.");  
  10.     int n = s1.find("your");  
  11.     cout<<"the first your pos:"<
  12.     n = s1.find("you",15);  
  13.     cout<<"the first you pos begin from 15:"<
  14.     n = s1.find_first_of("abcde");  
  15.     cout<<"find pos when character within abcde:"<
  16.     n = s1.find_first_of("abcde",3);  
  17.     cout<<"find pos when character within abcde from third character:"<
  18.       
  19.     return 0;  
  20. }  

程序运行结果如下:
STL——字符串用法详解_第1张图片
 

6.删除字符操作

    主要用erase函数,有两个迭代器输入参数,之间表示的字符将被删除掉。
    
[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     string s1("what's your name? my name is TOM. How do you do? Fine,thanks.");  
  10.     s1.erase(s1.begin(),s1.begin()+17);  
  11.     cout<<"after erase to s1 is:"<
  12.   
  13.     string s2 = "i love you forever!";  
  14.     s2.erase(s2.begin(),s2.end());  
  15.     cout<<"after erase to s2 is"<
  16.     return 0;  
  17. }  
程序运行结果如下:


7.比较操作

    主要是一句ASCII值来比较大小。若字符串s1“大于”s2,表明两者相比较时遇到了第一对不同的字符,字符串s1中第一个不同的字符比字符串s2中同样位置的字符在ASCII表中位置更靠后。
    C++ STL提供了多钟字符串比较方法,他们各具特色。其中最简单的就是使用非成员的重载运算符函数operator==、operator!=、operator>、operator<、operator>=和operator<=。

你可能感兴趣的:(STL——字符串用法详解)