C++字符串处理小结

C++中的字符串类型

常用的C++的字符串类型主要是std::string。它是模板std::basic_string的一个实例化。另外还有三个实例化std::wstringstd::u16stringstd::u32string,不过不是很常用。

std::basic_string<T>
std::string            std::basic_string<char>
std::wstring           std::basic_string<wchar_t>
std::u16string         std::basic_string<char16_t>
std::u32string         std::basic_string<char32_t>

具体可以参考:http://en.cppreference.com/w/cpp/string/basic_string

std::string

标准库中,std::string的成员函数和相关的算法特别多,从上面给出的链接里的内容,粗略计算一下,包括所有的重载函数,也有百余个了。但是在实际的工作使用中,很多时候,总是会感觉,C++对字符串的处理支持实在是弱爆了……感觉这个具有百余个方法的“巨”类用起来总是捉襟见肘。

std::string中的很多操作都是基于迭代器的——这样的话,很多操作,我们都需要先调用find或者直接遍历字符串拿到操作区间的迭代器,然后再进行实际的操作。成员函数中:inserterasereplace都是基于迭代器的操作。

同时,std::string也没有提供一些常用的字符串处理的方法,比如:简单的大小写转换,字符串连接,字符串分割等。

C++11中,提供了std::string的数字和字符串相互转换的算法:

  • 字符串==>数字 stoi string to int stol string to long stoll string to long long stoul string to unsigned long stoull string to unsigned long long stof string to float stod string to double stold string to long double
  • 数字==>字符串 to_string to_wstring

Boost中的字符串处理

Boost库通过算法的形式,提供了一些处理C++字符串的函数,虽然比起Java或者其它一些动态语言还是略显不足,但也算在一定程度上方便了我们对C++的字符串处理。

除了普通的字符串处理算法,Boost库还提供了一个正则表达式的函数库Boost.Regex。Boost.Regex已经被纳入到C++11的标准之中,但是我们常用的g++4.8.x(比如ubuntu14.04默认的g++版本就是4.8.x,公司的g++版本也是4.8.x)的C++标准库还没有实现正则表达式。

实际上,g++4.8.x已经定义了标准库正则表达式的类型和接口,但是只是占了个坑,并没有真正实现……结果可以编译通过,但是运行一直抛出异常。gcc4.9才真正实现了标准库的正则表达式

下面通过例子介绍一个Boost提供的字符串处理算法以及Boost.Regex的用法。

Boost的字符串算法

  • 头文件:#include <boost/algorithm/string.hpp>
  • Boost的很多修改字符串的算法都提供了直接修改传入字符串,名字不带copy返回一个新的字符串,名字带copy两个版本。

字符串大小写转换

C++标准库竟然连一个字符串大小写的转换函数都没有提供。

  • boost::algorithm::to_upper(), boost::algorithm::to_lower()直接修改传入的字符串,将其转换为对应字符串的大写或小写。
  • boost::algorithm::to_upper_copy(), boost::algorithm::to_lower_copy()返回一个新的大写或小写字符串。
  • 例子:
#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    std::string s("AbCdefG123 HijkLmn");
    cout << boost::algorithm::to_upper_copy(s) << endl;
    boost::algorithm::to_lower(s);
    cout << s << endl;
}
输出结果:
ABCDEFG123 HIJKLMN
abcdefg123 hijklmn

子串删除。

  • std::string提供了几个erase成员函数,都是基于“位置(下标或迭代器)”的删除:
basic_string& erase(size_type index = 0, size_type count = npos);
iterator erase(iterator position);
iterator erase(const_iterator position);
iterator erase(iterator first, iterator last);
iterator erase(const_iterator first, const_iterator last);
  • STL提供的remove系列的算法,由于其需要与其他容器通用,其删除时的比较函数只能是一个字符之间的比较(std::string中的一个字符相当于vector中的一个元素)。
ForwardIt remove(ForwardIt first, ForwardIt last, const T& value);
ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPredicate p);
OutputIt remove_copy(InputIt first, InputIt last, OutputIt d_first, const T& value);
OutputIt remove_copy_if(InputIt first, InputIt last, OutputIt d_first, UnaryPredicate p);
  • Boost提供了删除字符串子串的算法。
erase_all()删除主串中所有相等的子串。
erase_first()删除主串中第一个相等的子串。
erase_nth()删除主串中的第n个子串。**注意这里的n是从0开始的。**
erase_head()删除主串的前n个字符。
erase_tail()删除组成的后n个字符。
erase系列的copy版本

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    std::string s("AbCdefG123 HijkLmn");
    s += s;
    s += s;
    string s0 = s;
    cout << "Input String: " << s0 << endl;
    cout << boost::algorithm::erase_all_copy(s0, "AbC") << endl;
    cout << boost::algorithm::ierase_all_copy(s0, "ABC") << endl;
    cout << boost::algorithm::erase_first_copy(s0, "defG123") << endl;
    cout << boost::algorithm::ierase_first_copy(s0, "DEFG123") << endl;
    cout << boost::algorithm::erase_nth_copy(s0, "HijkLmn", 1) << endl;
    cout << boost::algorithm::ierase_nth_copy(s0, "HIJKLMN", 1) << endl;
    cout << boost::algorithm::erase_head_copy(s0, 3) << endl;
    cout << boost::algorithm::erase_tail_copy(s0, 5) << endl;
}
输出结果:
Input String: AbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmn
defG123 HijkLmndefG123 HijkLmndefG123 HijkLmndefG123 HijkLmn
defG123 HijkLmndefG123 HijkLmndefG123 HijkLmndefG123 HijkLmn
AbC HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmn
AbC HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmn
AbCdefG123 HijkLmnAbCdefG123 AbCdefG123 HijkLmnAbCdefG123 HijkLmn
AbCdefG123 HijkLmnAbCdefG123 AbCdefG123 HijkLmnAbCdefG123 HijkLmn
defG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmn
AbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 HijkLmnAbCdefG123 Hi

子串查找

  • Boost的这些字符串的find算法的返回值都是boost::iterator_range类型的一对迭代器。
  • find_first() 查找第一个匹配的子串。std::string::find能实现一样的功能。(find_first的实现应该是封装了这个成员函数,不过个人感觉这个算法用起来更方便。)
  • find_last() 查找最后一个匹配的子串。std::string::rfind能实现一样的功能。
  • find_nth() 查找第n(n>=0)个匹配的字符串。
  • find_head(s, n) 返回字符串的前n个字符。
  • find_tail(s, n) 返回字符串的最后n个字符。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    std::string s("AbCdefG123 HijkLmn");
    s += s;
    s += s;
    cout << "Input String: " << s << endl;
    boost::iterator_range<std::string::iterator> itRange = boost::algorithm::find_first(s, "123");
    cout << itRange << endl;
    cout << itRange.begin() - s.begin() << endl;
    cout << itRange.end() - s.begin() << endl;
    itRange = boost::algorithm::find_last(s, "123");
    cout << itRange << endl;
    cout << itRange.begin() - s.begin() << endl;
    cout << itRange.end() - s.begin() << endl;
    itRange = boost::algorithm::find_nth(s, "123", 1);
    cout << itRange << endl;
    cout << itRange.begin() - s.begin() << endl;
    cout << itRange.end() - s.begin() << endl;
    itRange = boost::algorithm::find_head(s, 5);
    cout << itRange << endl;
    cout << itRange.begin() - s.begin() << endl;
    cout << itRange.end() - s.begin() << endl;
    itRange = boost::algorithm::find_tail(s, 5);
    cout << itRange << endl;
    cout << itRange.begin() - s.begin() << endl;
    cout << itRange.end() - s.begin() << endl;
}

输出结果:
123
7
10
123
61
64
123
25
28
AbCde
0
5
jkLmn
67
72

连接字符串

  • Boost库提供了join()算法接受一个字符串容器作为第一个参数,根据第二个参数将这些字符串连接起来。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    vector<string> sVec{"ABC", "def", "GHIJK", "123456"};
    cout << boost::algorithm::join(sVec, "+**+") << endl;
}
输出结果:
ABC+**+def+**+GHIJK+**+123456

替换字符串

replace_first()替换第一个匹配的字符串。
replace_nth()替换第n(n>=0)个匹配的字符串。
replace_last()替换最后一个匹配的字符串。
replace_all()替换所有匹配的字符串。
replace系列的copy版本。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    string s("AbcDeFGHIJklmn");
    s += s;
    s += s;
    cout << "Input String: " << s << endl;
    cout << boost::algorithm::replace_all_copy(s, "AbcD", "**") << endl;
    cout << boost::algorithm::replace_first_copy(s, "AbcD", "**") << endl;
    cout << boost::algorithm::replace_last_copy(s, "AbcD", "**") << endl;
    cout << boost::algorithm::replace_nth_copy(s, "AbcD", 1, "**") << endl;
}
输出结果:
Input String: AbcDeFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmn
**eFGHIJklmn**eFGHIJklmn**eFGHIJklmn**eFGHIJklmn
**eFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmn
AbcDeFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmn**eFGHIJklmn
AbcDeFGHIJklmn**eFGHIJklmnAbcDeFGHIJklmnAbcDeFGHIJklmn

消除字符串两端的特殊字符

  • 很多时候,我们会希望删除字符左右两边的空白字符。Boost提供了几个算法来实现这个功能。
trim_left()删除字符串左边的空白。
trim_right()删除字符串右边的空白。
trim()删除字符串左右两边的空白。
trim系列的copy版本。
  • 有时候,我们想要删除的不仅仅是字符串左右两边的空白,而是其它一下特定的字符。
trim_left_if()
trim_right_if()
trim_if()
trim_if系列的copy版本,如果`trim_left_copy_if`...
  • Boost库的if系列算法通常传入一个"谓词参数", 如:
is_any_of
is_space 是否是空白字符。
is_alnum是否是字母或数字。
is_alpha是否时字母。
is_cntrl是否控制字符。
is_digit是否十进制数字。
is_graph是否图形字符。
is_lower是否小写字母。
is_print是否可打印字符。
is_punct是否标点符号。
is_upper是否大写字符。
is_xdigit是否十六进制数字。
is_from_range(from, to)是否from <= ch <= to。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    string s("   AbcDeF GHIJklmn      ");
    cout << "Input String: <" << s << '>' << endl;
    cout << '<' << boost::algorithm::trim_left_copy(s) << '>' << endl;
    cout << '<' << boost::algorithm::trim_right_copy(s) << '>' << endl;
    cout << '<' << boost::algorithm::trim_copy(s) << '>' << endl;
    cout << endl;
    string s1("==ABCD Efgh=IJK==-==   ");
    cout << "Input String: <" << s1 << '>' << endl;
    cout << '<' << boost::algorithm::trim_copy_if(s, boost::algorithm::is_any_of(" -=")) << '>' << endl;
}
    输出结果:
    Input String: <   AbcDeF GHIJklmn      >
    <AbcDeF GHIJklmn      >
    <   AbcDeF GHIJklmn>
    <AbcDeF GHIJklmn>
    Input String: <==ABCD Efgh=IJK==-==   >
    <AbcDeF GHIJklmn>

匹配比较

starts_with(s, sub) s是否以sub开头, 即前缀。
ends_with(s, sub) s是否以sub结尾, 即后缀。
contains(s, sub) s是否包含sub。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
using namespace std;
int main()
{
    string s("abcdefGHIJKLMN");
    cout << boost::algorithm::starts_with(s, "abcd") << endl;
    cout << boost::algorithm::starts_with(s, "abcD") << endl;
    cout << boost::algorithm::ends_with(s, "MN") << endl;
    cout << boost::algorithm::ends_with(s, "mn") << endl;
    cout << boost::algorithm::contains(s, "efG") << endl;
    cout << boost::algorithm::contains(s, "WWW") << endl;
}
输出结果:
1
0
1
0
1
0

分割字符串

  • Boost库提供了split算法,根据指定的字符集合对字符串进行分割。

例子:

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    string s("abc 123 cde");
    vector<string> sVec;
    boost::algorithm::split(sVec, s, boost::algorithm::is_space());
    for (auto& str : sVec)
    {
        cout << str << endl;
    }
    cout << "--------分割线--------" << endl;
    s = " abc 123 cde   ";
    boost::algorithm::split(sVec, s, boost::algorithm::is_space());
    for (auto& str : sVec)
    {
        cout << str << endl;
    }
    cout << "--------分割线--------" << endl;
    s = "--abc 123--cde-";
    boost::algorithm::split(sVec, s, boost::algorithm::is_any_of(" -"));
    for (auto& str : sVec)
    {
        cout << str << endl;
    }
}
输出结果:
abc
123
cde
--------分割线--------
//空行
abc
123
cde
//空行
//空行
//空行
--------分割线--------
//空行
//空行
abc
123
//空行
cde
//空行
  • 注: boost的很多(但不是全部)字符串算法都带有忽略大小写的版本,相差只是以'i'开头。

正则表达式

简介

简单地说,Boost提供了三个类型三个算法来处理正则表达式:

  • 三个类型
    • 正则表达式使用boost::regex来表示。
    • 正则表达式的匹配的子串结果使用boost::smatchboost::sub_match来表示。
  • 三个算法
    • 判断整个字符串是否与正则表达式匹配:boost::regex_match()
    • 在字符串中搜索与正则表达式匹配的子串:boost::regex_search()
    • 替换掉字符串中所有与正则表达式匹配的字串:boost::regex_replace()

关于正则表达式的学习,可以参考这篇文章

例子

** 下面通过例子和注释简单说明其用法。**

#include <boost/regex.hpp>
#include <iostream>
#include <string>
using namespace std;
int main()
{
    boost::regex rgx("(\\w+)\\s(\\w+)"); 
    string s("abcd efgh");
    // boost::regex_match() 当字符串和正则表达式<完全匹配>的时候返回true,
    // 否则返回false。
     cout << boost::regex_match(s, rgx) << endl; 
     cout << "========分割线========" << endl;
     // boost::regex_search() 找到第一个和正则表达式匹配的子串则返回true,
     // 具体匹配子串的信息存放在boost::smatch类型的参数里。否则返回false。
     // boost::smatch实际上是持有boost::sub_match的元素的容器。
     // boost::sub_match继承自类std::pair,
     // 对应的匹配子串由first和second成员表示:[first, second)。
     boost::smatch result;
     if (boost::regex_search(s, result, rgx))
     {
         for (size_t i = 0; i < result.size(); ++i)
        {
            //result[0] 正则表达式的匹配结果。
            //result[1] 第一个分组的匹配结果。
            //result[2] 第二个分组的匹配结果。
            cout << result[i] << endl;
         }
     }
     cout << "========分割线========" << endl;
 
     rgx = "(\\w+)\\s\\w+";
     if (boost::regex_search(s, result, rgx))
     {
         for (size_t i = 0; i < result.size(); ++i)
         {
             //result[0] 正则表达式的匹配结果
             //result[1] 分组的匹配结果
             cout << result[i] << endl;
         }
     }
     cout << "========分割线========" << endl;
 
     rgx = "\\w+\\s(\\w+)";
     if (boost::regex_search(s, result, rgx))
     {
         for (size_t i = 0; i < result.size(); ++i)
         {
            cout << result[i] << endl;
         }
     }
     cout << "========分割线========" << endl;
     rgx = "\\w+\\s\\w+";
     if (boost::regex_search(s, result, rgx))
     {
         for (size_t i = 0; i < result.size(); ++i)
         {
              cout << result[i] << endl;
          }
      }
      cout << "========分割线========" << endl;
      rgx = "(\\d+)\\s(\\w+)";
      if (boost::regex_search(s, result, rgx))
      {
         for (size_t i = 0; i < result.size(); ++i)
         {
             cout << result[i] << endl;
         }
      }
      cout << "========分割线========" << endl;
      // 遍历正则匹配整个字符串。
      s = "abcd efgh ijk www";
      rgx = "\\w+\\s\\w+";
      auto begin = s.cbegin();
      auto end = s.cend();
      while (boost::regex_search(begin, end, result, rgx))
      {
           cout << result[0] << endl;
           begin = result[0].second;
      }
      cout << "========分割线========" << endl;

    // boost::regex_replace() 替换掉字符串中<所有>匹配的子串。

    //结果输出到一个Output Iterator。
     boost::regex_replace(std::ostreambuf_iterator<char>(std::cout), s.cbegin(), s.cend(), rgx, "666666");
     cout << endl;
      //直接返回结果
     cout << boost::regex_replace(s, rgx, "2233333") << endl; //每一个匹配
}

输出结果:
1
========分割线========
abcd efgh
abcd
efgh
========分割线========
abcd efgh
abcd
========分割线========
abcd efgh
efgh
========分割线========
abcd efgh
========分割线========
========分割线========
abcd efgh
ijk www
========分割线========
666666 666666
2233333 2233333

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Golang语言社区

Golang语言之defer-再议

defer语句被用于预定对一个函数的调用。我们把这类被defer语句调用的函数称为延迟函数。注意,defer语句只能出现在函数或方法的内部。 一条defer语句...

355140
来自专栏儿童编程

Python Turtle帮助文档梳理

Python Turtle帮助文档真的很多,几十屏拉不到头。其中很多部分是重复的。近期进行了梳理,我将其分为全局控制、画布设置、画笔设置、画笔操作、互动等五个部...

28030
来自专栏老司机的技术博客

golang学习笔记4:基本类型和运算符

布尔型的值只可以是常量 true 或者 false。一个简单的例子: var b bool = true 。两个类型相同的值可以使用相等 == 或者不等 != ...

30330
来自专栏技术碎碎念

python3 入门 (一) 基础语法

1.编码问题 默认情况下,Python 3源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。 也可以为源码文件指定不同的编码,在文件头部加上...

30970
来自专栏代码世界

Python基础数据类型之字典

 基础数据类型之字典 ps:数据类型划分:可变数据类型和不可变数据类型。 不可变数据类型:元组(tupe)、布尔值(bool)、整数型(int)、字符串(str...

35890
来自专栏有趣的django

19.JavaScript

简介 JavaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的语言,内置支持类型 1.注释 单行 // 多行 /* */ 2.引用...

33250
来自专栏杨龙飞前端

es6中的let声明变量与es5中的var声明变量的区别,局部变量与全局变量

21670
来自专栏码洞

《快学 Go 语言》第 7 课 —— 冰糖葫芦串

字符串通常有两种设计,一种是「字符」串,一种是「字节」串。「字符」串中的每个字都是定长的,而「字节」串中每个字是不定长的。Go 语言里的字符串是「字节」串,英文...

10450
来自专栏谈补锅

正则限制输入为数字,且最多输入2位小数 之 新写法

  原本小程序需要一个限制文本框输入为数字,且最多保留2位小数的效果,网上找到的例子感觉有点繁琐,就自己写了一个。

66920
来自专栏Python小屋

小议Python列表和元组中的元素地址连续性

众所周知,在Python中字典和集合依赖元素哈希表来存储,并不存在传统意义上的所谓元素“顺序”,当然,如果需要一个有序的字典可以使用collections模块提...

366100

扫码关注云+社区

领取腾讯云代金券