string常用的一些处理操作

• 引言
• string字符串常见处理
• • 查找
  • • find（）——查找指定字符串或指定字符的位置
    • • 1. 查找指定的字符串
      • 2. 查找指定的字符
    • rfind（）——反向查找指定字符的位置
    • find_first_of()——查找第一个匹配的字符集的位置
    • find_last_of()——查找最后一个匹配的字符集的位置
    • find_first_not_of()——查找第一个不为指定字符集的字符位置
    • find_last_not_of()——查找最后一个不为指定字符集的字符位置
  • 删除
  • • erase()函数介绍
    • • 使用示例
      • 运行结果
      • 示例二
      • 运行结果
      • 示例三
      • 运行结果
  • 追加
  • • 追加字符
  • 反转
  • 查找字符串中非字母数字的字符

引言

日常开发中经常会用到string字符串的一些处理需求，查找子串，删除特定字符，将某些字符或者字符串追加到string字符串后面，反转原来的字符串等，本文主要记录以上所述的几种字符串处理方式中可能会用到的函数，以及这些函数简单的使用示例。

string字符串常见处理

查找

find（）——查找指定字符串或指定字符的位置

使用 std::string 类的一个成员函数find(),它允许你快速地检查一个字符串是否包含另一个字符串或字符,返回指定字符或者子字符串在字符串中首次出现的位置，如果未找到则返回std::string::npos。
find()函数的介绍：

size_t find(const string& str, pos_type pos = 0) const;  
size_t find(const char* s, size_type pos = 0) const;  
size_t find(char c, size_type pos = 0) const;

参数介绍：
str: 要查找的子字符串。
s: 要查找的 C 字符串。
c: 要查找的字符。
pos: 开始搜索的位置（默认为0，即从字符串的开始位置搜索）。
返回值：如果找到，则返回子字符串或字符在主字符串中的起始位置；如果没找到，则返回 std::string::npos。

注意点：返回的位置是基于 0 的索引，所以返回 0 表示子字符串或字符位于主字符串的开始位置。

使用这个函数时，最好先检查返回值是否等于 std::string::npos，以确保你真的找到了子字符串或字符，而不是简单地检查返回值是否为0。

1. 查找指定的字符串

find()函数会返回子字符串在字符串中首次出现的位置，如果未找到则返回std::string::npos。
下面是简单示例：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
    std::string sub_str = "World";  
      
    // 查找子字符串在字符串中的位置  
    size_t found = str.find(sub_str);  
      
    if (found != std::string::npos) {  
        std::cout << "子字符串 '" << sub_str << "' 在字符串中的位置是: " << found << std::endl;  
    } else {  
        std::cout << "未找到子字符串 '" << sub_str << "'" << std::endl;  
    }  
      
    return 0;  
}

运行结果：

2. 查找指定的字符

find()函数会返回指定字符在字符串中首次出现的位置，如果未找到则返回std::string::npos。
示例代码：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
    char c = 'o';  
      
    // 查找字符在字符串中的位置  
    size_t found = str.find(c);  
      
    if (found != std::string::npos) {  
        std::cout << "字符 '" << c << "' 在字符串中的位置是: " << found << std::endl;  
    } else {  
        std::cout << "未找到字符 '" << c << "'" << std::endl;  
    }  
      
    return 0;  
}

运行结果：

rfind（）——反向查找指定字符的位置

从字符串的末尾开始查找第一个指定的字符，可以使用标准库中的 std::string 类和其成员函数rfind()。下面是一个示例代码，演示如何实现这个功能：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
    char targetChar = 'o';  
      
    // 从字符串末尾开始反向查找目标字符  
    size_t pos = str.rfind(targetChar);  
      
    if (pos != std::string::npos) {  
        std::cout << "目标字符 '" << targetChar << "' 在字符串中的位置为: " << pos << std::endl;  
    } else {  
        std::cout << "目标字符 '" << targetChar << "' 在字符串中未找到." << std::endl;  
    }  
      
    return 0;  
}

运行结果：

在上面的示例基础上做一个延申，可以反向查找字符串中第二个指定的字符，只需将第二次查找的开始位置设置为第一次查得的位置索引即可。
下面是一个简单示例：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
    char targetChar = 'o';  
    size_t firstPos = std::string::npos;  
    size_t secondPos = std::string::npos;  
      
    // 从字符串末尾开始反向查找目标字符  
    firstPos = str.rfind(targetChar); //找到指定字符在字符串中第一次出现的位置 
    if (firstPos != std::string::npos) {  
        secondPos = str.rfind(targetChar, firstPos - 1);  //以指定字符在字符串第一次出现的位置为开始位置，向前查找第一个出现指定字符的位置
        if (secondPos != std::string::npos) {  
            std::cout << "目标字符 '" << targetChar << "' 在字符串中的第二个位置为: " << secondPos << std::endl;  
        } else {  
            std::cout << "在第一个目标字符之前未找到第二个目标字符." << std::endl;  
        }  
    } else {  
        std::cout << "只找到一个目标字符." << std::endl;  
    }  
      
    return 0;  
}

运行结果：

find_first_of()——查找第一个匹配的字符集的位置

这个函数返回第一个与指定字符集中的字符匹配的字符的索引。如果没有找到匹配的字符，则返回std::string::npos。

1. find_first_of()函数介绍：

size_t find_first_of(const string& str, size_t pos = 0) const;  
size_t find_first_of(const char* s, size_t pos = 0) const;  
size_t find_first_of(char c, size_t pos = 0) const;

2.参数说明：
str：要查找的字符集（一个字符串），可以是另一个字符串或C风格字符串。
s：要查找的字符集（一个C风格字符串）。
c：要查找的单个字符。
pos：开始搜索的位置（默认为0，即从字符串的开始位置搜索）。
返回值：如果找到匹配的字符，则返回该字符在主字符串中的索引；如果未找到，则返回 std::string::npos。

这个函数可以用于查找一个字符串中是否存在某个特定的字符或字符集，例如检查一个字符串是否包含逗号、句号等。它返回的是第一个匹配的字符的位置，而不是所有匹配的字符的位置。如果要查找所有匹配的字符，可以使用循环结合 find_first_of() 函数来实现。
3. 示例（没有给出完整代码，请自行补充）

std::string str = "Hello, World!";  
char c = ',';  
size_t found = str.find_first_of(c);  
if (found != std::string::npos) {  
    std::cout << "字符 '" << c << "' 在字符串中的位置是: " << found << std::endl;  
} else {  
    std::cout << "未找到字符 '" << c << "'" << std::endl;  
}

4.运行结果：

find_last_of()——查找最后一个匹配的字符集的位置

这个函数返回最后一个与指定字符集中的字符匹配的字符的索引。如果没有找到匹配的字符，则返回std::string::npos。
1.函数介绍：

size_t find_last_of(const string& str, size_t pos = npos) const;  
size_t find_last_of(const char* s, size_t pos = npos) const;  
size_t find_last_of(char c, size_t pos = npos) const;

2.参数说明：

str：要查找的字符集（一个字符串），可以是另一个字符串或C风格字符串。
s：要查找的字符集（一个C风格字符串）。
c：要查找的单个字符。
pos：开始搜索的位置（默认为 std::string::npos，表示从字符串的末尾向前搜索）。
返回值：如果找到匹配的字符，则返回该字符在主字符串中的索引；如果未找到，则返回 std::string::npos。

这个函数可以用于查找一个字符串中最后一个出现的特定字符或字符集，例如检查一个字符串中最后一个出现的逗号或句号的位置。它返回的是最后一个匹配的字符的位置，而不是所有匹配的字符的位置。如果要查找所有匹配的字符，可以使用循环结合 find_last_of() 函数来实现。
3.使用示例

    std::string str = "Hello, World!";
    char c = 'o';
    size_t found = str.find_last_of(c);
    if (found != std::string::npos) {
        std::cout << "字符 '" << c << "' 在字符串中的位置是: " << found << std::endl;
    }
    else {
        std::cout << "未找到字符 '" << c << "'" << std::endl;
    }

4.运行结果

find_first_not_of()——查找第一个不为指定字符集的字符位置

这个函数返回第一个不是指定字符集中的字符的索引。如果没有找到非匹配的字符，则返回std::string::npos。
1.函数介绍

size_t find_first_not_of(const string& str, size_t pos = 0) const;  
size_t find_first_not_of(const char* s, size_t pos = 0) const;  
size_t find_first_not_of(char c, size_t pos = 0) const;

2.参数介绍
str：要排除的字符集（一个字符串），可以是另一个字符串或C风格字符串。
s：要排除的字符集（一个C风格字符串）。
c：要排除的单个字符。
pos：开始搜索的位置（默认为0，即从字符串的开始位置搜索）。
返回值：如果找到不是指定字符集中的字符，则返回该字符在主字符串中的索引；如果未找到，则返回 std::string::npos。

这个函数可以用于查找一个字符串中第一个不是常见字符（如空格、制表符等）的位置，或者查找第一个不是指定字符集中的字符的位置。它返回的是第一个不是匹配的字符的位置，而不是所有不是匹配的字符的位置。如果要查找所有不是匹配的字符，可以使用循环结合 find_first_not_of() 函数来实现。
3.示例

 std::string str = "Hello, World!";
    char c = ',';
    size_t found = str.find_first_not_of(c);//查找第一个不为,的字符所在位置
    if (found != std::string::npos) {
        std::cout << "字符 '" << c << "' 在字符串中的位置是: " << found << std::endl;
    }
    else {
        std::cout << "未找到字符 '" << c << "'" << std::endl;
    }

4.运行结果

find_last_not_of()——查找最后一个不为指定字符集的字符位置

这个函数返回最后一个不是指定字符集中的字符的索引。如果没有找到非匹配的字符，则返回std::string::npos。
函数介绍如上find_first_not_of()一样。
1.使用示例：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello World    "; // 包含末尾空格的字符串  
    size_t pos = str.find_last_not_of(' ') ; // 查找末尾最后一个不为空格的元素的位置，即d的下标索引  
  
    std::cout << pos << std::endl; // 输出: Hello World  
    return 0;  
}

运行结果：

删除

std::string 的 erase() 函数在 C++ 中用于删除字符串中的一部分字符。

erase()函数介绍

1.size_type erase(size_type index = 0, size_type count = npos)
此形式从 index 开始，删除 count 个字符。
如果只提供 index，则默认删除从 index 开始到字符串结束的所有字符。
如果 count 超过了从 index 到字符串结束的字符数，那么整个字符串都会被删除。

2.iterator erase(const_iterator position)
此形式删除单个字符，即从 position 指向的字符开始，删除到字符串的末尾。

3.iterator erase(const_iterator first, const_iterator last)
此形式删除一个范围的字符，即从 first 指向的字符开始，到 last 指向的字符结束（不包括 last）。

使用示例

#include <iostream>  
#include <string>  
  
int main() {  
    std::string s = "Hello, World!";  
    s.erase(0, 5);  // 删除从索引0开始的5个字符
    std::cout << s << std::endl;  
    return 0;  
}

运行结果

示例二

使用iterator erase(const_iterator position)去掉字符串末尾的空格。

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello World    "; // 包含末尾空格的字符串  
    str.erase(str.find_last_not_of(' ') + 1); // 删除末尾空格  
  
    std::cout << str << std::endl; // 输出: Hello World  
    return 0;  
}

运行结果

示例三

使用iterator erase(const_iterator first, const_iterator last)删除指定范围内的元素。

void test8() 
{
    string str = "shguygdf";
    str.erase(str.begin(),str.begin()+3);
    cout <<"original string:shguygdf"<<"删除之后："<< str << endl;

    string str1 = "hellohusdd";
    str1.erase(str1.size()-1);
    cout << "original string:hellohusdd" << "删除之后：" << str1 << endl;


    vector<char> cVec = {'d','f','c','g','a','s'};
    cVec.erase(cVec.begin(),cVec.begin()+2);
    for (const auto &value:cVec) 
    {
        cout << value << " ";
    }
    cout << endl;
}

运行结果

追加

追加字符

1.使用+=或者push_back()来追加字符。
2. 使用+=或者append()来追加字符串
下面是示例：

#include <iostream>  
#include <string>  
  
int main() {  
   	string str2 = "hu";
    str2.push_back('A');
    str2 += 'D';
    str2 += "hdf";
    cout << "str2追加字符后：" << str2 << endl;

    str2.append(" husdf");
    cout << "str2追加字符后：" << str2 << endl;
    return 0;  
}

运行结果：

注意在使用+=追加字符和字符串的时候，不能连续同时追加字符和字符串。
像下面第三行代码，就是不允许的，运行时会出现错误，但是编译不报错。

	string str2 = "hu";
    str2.push_back('A');
    str2 += 'D' + "hdf";
    cout << "str2追加字符后：" << str2 << endl;

上述代码段运行结果：

反转

1.使用reverse()实现字符串的反转。
2.使用反向迭代器实现字符串的反转。
使用示例：

    string str3 = "hello C++";
    std::reverse(str3.begin(),str3.end());
    cout << "original string:hello C++"<<"反转之后："<<str3 << endl;
    
    string strTemp(str3.rbegin(), str3.rend());;
    cout << "original string:" <<str3<< "反转之后：" << strTemp << endl;

运行结果：

查找字符串中非字母数字的字符

std::isalnum 是 C++ 标准库中的一个函数，用于检查给定的字符是否是字母或数字。该函数属于 头文件。
示例一：

#include <iostream>  
#include <cctype>  // 包含 std::isalnum  
  
int main() {  
    char c1 = 'a';  
    char c2 = '1';  
    char c3 = ' ';  
    char c4 = '$';  
  
    std::cout << std::boolalpha;  // 输出 true 或 false，而不是 1 或 0  
    std::cout << "c1 is alphanumeric: " << std::isalnum(c1) << '
';  // 输出 true  
    std::cout << "c2 is alphanumeric: " << std::isalnum(c2) << '
';  // 输出 true  
    std::cout << "c3 is alphanumeric: " << std::isalnum(c3) << '
';  // 输出 false  
    std::cout << "c4 is alphanumeric: " << std::isalnum(c4) << '
';  // 输出 false  
  
    return 0;  
}

示例二：
删除字符串中所有非字母数字的字符。

#include <iostream>  
#include <string>  
#include <algorithm>  
  
int main() {  
    string s = "nihafd@ ewfds12!";
    cout <<"original string:s="<< s << endl;
    s.erase(remove_if(s.begin(), s.end(), [](char c) {return !isalnum(c); }), s.end());
    cout << s << endl;
    return 0;  
}

运行结果：

注意：这里不能使字符串中含有中文，否则程序运行的时候会崩溃。
字符串操作其实就是对其操作函数的使用熟练程度，今天先写到这里，后面再补充吧。