C/C++之 C++ String（字符串）

雨点打透心脏的1/2处 2022-09-28 11:45 164阅读 0赞

> **Tips：**  
>  1. 本人当初学习C/C++的记录。  
>  2. 资源很多都是来自网上的，如有版权请及时告知！  
>  3. 可能会有些错误。如果看到，希望能指出，以此共勉！

要想使用标准C++中string类，必须要

#include <string> // 注意是<string>，不是<string.h>，带.h的是C语言中的头文件
    using std::string;或using namespace std;

下面你就可以使用string了。

# 声明一个C++字符串 #

声明一个字符串变量很简单：  
`string str;`  
  这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把str初始化为一个空字符串。string类的构造函数和析构函数如下：  
![string][]  
  当构造的string太长而无法表达时会抛出length\_error异常

# string对象的特性描述 #

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

这里另一个需要指出的是reserve()函数，这个函数为string重新分配内存。重新分配的大小由其参数决定，默认参数为0，这时候会对string进行非强制性缩减。  
![属性][SouthEast]

# string的赋值 #

1、string &operator=(const string &s);          // 把字符串s赋给当前字符串
    2、string &assign(const char *s);               // 用C风格字符串s赋值
    3、string &assign(const char *s, int n);        // 用C风格字符串s开始的n个字符赋值（注意：越界问题）
    4、string &assign(const string &s);             // 把字符串s赋给当前字符串
    5、string &assign(int n, char c);               // 用n个字符c赋值给当前字符串
    6、string &assign(const string &s, int start, int n);      // 把字符串s中从start开始的n个字符赋给当前字符串（如果n 超过了s的长度，则返回，不够n个也结束）
    7、string &assign(const_iterator first,const_itertor last);// 把first和last迭代器之间的部分赋给字符串

![赋值][SouthEast 1]

# string的连接 #

1、string &operator+=(const string &s);             // 把字符串s连接到当前字符串的结尾
    2、string &append(const char *s);                   // 把c类型字符串s连接到当前字符串结尾
    3、string &append(const char *s, int n);            // 把c类型字符串s的前n个字符连接到当前字符串结尾
    4、string &append(const string &s);                 // 同operator+=（）
    5、string &append(const string &s, int pos, int n); // 把字符串s中从pos开始的n个字符连接到当前字符串的结尾
    6、string &append(int n,char c);                    // 在当前字符串结尾添加n个字符c
    7、string &append(const_iterator first,const_iterator last); // 把迭代器first和last之间的部分连接到当前字符串的结尾
    8、void push_back(char ch);   // 在当前字符串后面拼接上字符ch

![连接][SouthEast 2]

> **注意：**  
> 可以将string对象和字符串常量直接连接，但是，必须保证+两侧至少有一个收听对象。例如：string str13 = “hello”+”+str; 是错误的

# 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

C++字符串支持常见的比较操作符（ >,>=,<,<=,==,!= ），甚至支持string与C-string的比较（如 str< “hello”）。在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序逐一进行比较。字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。举例如下：

string s(“abcd”);
    s.compare(“abcd”);       // 返回0
    s.compare(“dcba”);       // 返回一个小于0的值
    s.compare(“ab”);         // 返回大于0的值
    s.compare(s);              // 相等
    s.compare(0,2,s,2,2);      // 用”ab”和”cd”进行比较 小于零
    s.compare(1,2,”bcx”,2);  // 用”bc”和”bc”比较。

# 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 ) 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 ); // 在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

![插入][SouthEast 3]

# string类的删除函数： #

iterator erase( iterator first, iterator last ); // 删除first至last之间的所有字符，返回删除后迭代器的位置
    iterator erase( iterator it );                   // 删除it指向的字符，返回删除后迭代器的位置
    string &erase( int pos = 0, int n = npos );      // 删除pos开始的n个字符，返回修改后的字符串
    void pop_back();                                 // 删除当前字符串的最后一个字符

# string类的迭代器处理： #

string提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。  
用string::iterator或string::const\_iterator 声明迭代器变量，const\_iterator不允许改变迭代器的内容，但是其自身可以改变。  
  通过设置迭代器string:: reverse\_iterator, string::const\_reverse\_iterator实现从后向前  
  string 迭代器可以使用解引用符（\*）以及自增自减运算符（++/–）  
迭代器可以用==或!=进行比较，指向同一元素则为相等  
![迭代][SouthEast 4]

## C++中string对象中的字符操作 ##

经常要对 string 对象中的单个字符进行处理，例如，通常需要知道某个特殊字符是否为空白字符、字母或数字。下表列出了各种字符操作函数，适用于 string 对象的字符（或其他任何 char 值）。这些函数都在cctype头文件中定义。

<table> 
 <thead> 
  <tr> 
   <th>函数原型</th> 
   <th>作用</th> 
   <th>ASCII码值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int isalnum( int ch )</td> 
   <td>若 ch 是字母或数字，则为 True。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isalpha( int ch )</td> 
   <td>若 ch 是字母，则返回非零</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int iscntrl(int ch )</td> 
   <td>若 ch 是控制字符，则返回非零</td> 
   <td>0~0x1F</td> 
  </tr> 
  <tr> 
   <td>int isdigit(int ch )</td> 
   <td>若 ch 是数字，则为 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isgraph(int ch )</td> 
   <td>若 ch 不是空格，但可打印，则返回非零</td> 
   <td>0x21~0x7E</td> 
  </tr> 
  <tr> 
   <td>int islower(int ch )</td> 
   <td>若 ch 是小写字母，则为 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isprint(int ch)</td> 
   <td>若ch 是可打印的字符，则为 true。</td> 
   <td>0x20~0x7E</td> 
  </tr> 
  <tr> 
   <td>int ispunct(int ch)</td> 
   <td>若ch 是标点符号，则 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isspace(int ch)</td> 
   <td>若ch 是空白(空格、换行等)字符，则为 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isupper(int ch)</td> 
   <td>若ch 是大写字母，则 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isxdigit(int ch)</td> 
   <td>若ch是 十六进制数0~9，A~F，a~f，则为 true。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int tolower(int ch)</td> 
   <td>若ch 大写字母，返回其小写字母形式，否则直接返回 c。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int toupper(int ch )</td> 
   <td>若ch 是小写字母，则返回其大写字母形式，否则直接返回 c。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>int isascii( int ch )</td> 
   <td>若ch是ASCII码0~127，则返回非零</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

可以使用下标操作符\[\]及at()函数对string对象元素进行索引  
const char &operator\[\](int n)const; // 运算符的重载  
const char &at()(int n)const; // 成员函数  
char &operator\[\](int n);  
char &at()(int n);  
const char \*data()const; // 返回一个非null终止的c风格的字符数组  
operator\[\]和at（）均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out\_of\_range异常，下标运算符\[\]不提供检查访问。  
![索引][SouthEast 5]

## C++风格字符串和C风格字符串的转换 ##

由C++风格字符串得到对应的C风格字符串的方法如下：

const char * data() const;                  // 以字符数组的形式返回字符串内容，但并不添加'\0'。（VS中也会添加'\0'??）
    const char * c_str() const;                 // 返回一个以'\0'结尾的字符数组
    int copy(char *s, int n, int pos) const;        // 将当前字符串从pos开始的n个字符拷贝到s中

![转换][SouthEast 6]  
  由C风格字符串得到对应的C++风格字符串的方法：直接赋值即可。

> C++字符串并不以’\\0’结尾。

## 字符串中的中文操作 ##

每个汉字为两个字符。

## C++11新增原始字符串 ##

所谓的原始字符串就是，字符串中每个字符都表示他自己，例如：\\0不再是转义字符，而是表示\\和0。再例如：再也不用使用\\”来输出”了。  
原始字符串使用()来界定字符串的范围，并且使用前缀R来识别原始字符串。  
![原始字符串][SouthEast 7]  
  在支持C++11特性的编译器中，上图中的两句效果是一样的！VS2010不支持

[string]: /images/20220708/983b99a619b249fe8cf92df5cb71f0a7.png
[SouthEast]: /images/20220708/aa8ca195593a4769986aa0478a4c880d.png
[SouthEast 1]: /images/20220708/d29bf6936dff4af787f6fb98efbccb49.png
[SouthEast 2]: /images/20220708/fdf13ad64f1241cb880589bfa3f2bb67.png
[SouthEast 3]: /images/20220708/c05e3a64552445089973a97ea1cbebf7.png
[SouthEast 4]: /images/20220708/3a3f477dfe9a4e27b2c7194655215bf0.png
[SouthEast 5]: /images/20220708/ae7a0812e29a48f78fdd70ad117d540f.png
[SouthEast 6]: /images/20220708/ad2fddf36d024f329ee54cee4b5d404b.png
[SouthEast 7]: /images/20220708/637f1c725ece40d5aa78ee0c08ed615c.png