boost-字符文本处理

1、lexical_cast

  一些常见的数值，字符互转函数：

整型int：
itoa()、_itoa_s
atoi()、_ttoi

无符号整型unsigned int：
_ultoa_s()、_ultot_s
strtoul()、_tcstoul

长整型long long：
_i64toa_s()、_i64tot_s
_atoi64()、_ttoi64，strtoll(C99/C++11)

无符号长整型unsigned long long：
_ui64toa_s()、_ui64tot_s
_strtoui64()、_tcstoui64，strtoull(C99/C++11)

浮点型double：
atof()、_ttof，strtod
char buf[10] = {0};
_gcvt_s(buf, 10, 12.345, 5);//最后一个参数为要转换的位数

  boost的lexical_cast提供数字、字符串之间的相互转换，可以用来替代上面的atoi、itoa、strtol等，使用需要包含boostlexical_cast.hpp：

    int x = lexical_cast<int>("100");
    double d = lexical_cast<double>("3.14");
    string str = lexical_cast<string>(100);
    string str2 = lexical_cast<string>(3.14);

  需要注意的是当浮点数float、double转化为字符串的时候会将不精确的数字也转换，如上面的3.14转换成了"3.1400000000000001"，而且小数位不会进行四舍五入，比如2.99会转换为"2.9990000000000001"，如果需要指定小数位数的转换的话可以使用后面的format，而且format会对指定小数位数的浮点型转换取四舍五入（同sprintf_s()以及使用ostringstream将浮点型转换为指定小数位数的字符串），如后面所示。

  如果输入的是非法值导致lexical_cast无法执行转换操作时会抛出bad_lexical_cast异常，它是std::bad_cast的派生类，我们可以实现一个模板函数来判断用户输入的是否是有效的数值：

template<typename T>
bool num_valid(const char* pStr)
{
    try
    {
        lexical_cast<T>(pStr);
        return true;
    }
    catch (bad_lexical_cast)
    {
        return false;
    }
}

bool bRet;
char* pInputStr = "123";
bRet = num_valid<int>(pInputStr); //输入有效
pInputStr = "123test";
bRet = num_valid<int>(pInputStr); //输入无效

  lexcical_cast对于转换对象有三个要求：转换起点对象是可流输出的，即定义了operator<<；转换终点对象是可流输入的，即定义了operator>>；转换终点对象必须是可缺省构造和拷贝构造的。C++中的内建类型int、double等以及std::string都满足前面的可转换条件，而STL中的容器则不可转换，对于用户自定义类型需要满足前面三个条件可以进行转换。

2、format

  format可以把参数格式化到一个字符串中，而且是类型安全的，使用format需要包含头文件"boostformat.hpp"，使用示例：

    string str = "value";
    int num = 100;

    cout << boost::format("%s: %d 
") % str % num; //format支持流输出，可以直接向输出流cout输出内部保存的字符串，输出value: 100

    boost::format fmt("%s: %d, %s: %d 
");
    fmt % str % num;
    fmt % str % num; //可以多次输入参数
    string strFmt = fmt.str();
    cout << strFmt; //输出为value: 100, value: 100

    fmt.clear();
    fmt % "test" % 99 % "test2" % 100;
    cout << fmt; //输出为test: 99, test2: 100

    boost::format fot("%1%: %2%, %1%: %2% 
"); // %n%用来指定使用的参数
    fot % str % num;
    cout << fot; //输出 value: 100, value: 100

    fot.parse("%f 
");
    fot % 3.14;
    cout << fot; //输出 3.140000

  format对象的一些成员函数：

  str()：返回内部已经格式化好的字符串
  size()：相当于str().size()
  clear()：清空内部缓存，执行后立即调用str()或size()会抛出异常
  parse()：清空内部缓存并使用一个新的格式化字符串，执行后立即调用str()或size()会抛出异常

  参数及其数量必须匹配格式化字符串中要求的参数及数量，否则使用<<输出format对象、调用成员函数str()、size()等会抛出异常，所以使用format的时候最好加上异常处理。

  format基本继承了printf的格式化语法，如：

   %05d：输出宽度为5的整数，不足位用0填充
   %-8.3f：输出左对齐，宽度为8，小数位3位的浮点数
   % 10s：输出宽度为10的字符串，不足位用空格填充
   %5X：输出宽度为5的大写十六进制整数

  format对于指定位数的小数是会进行四舍五入的，如下所示：

    double d = 299.999;
    boost::format fmt("%.3lf");
    fmt % d;
    std::string s = fmt.str(); //"299.999"

    boost::format fmt2("%.2lf");
    fmt2 % d;
    s = fmt2.str(); //"300.00"

  format要比printf速度慢几倍，可以先建立const format对象，然后拷贝这个对象进行格式化操作，这样比直接使用format对象能够提高一些速度：

    const format fmt("%d, %d");
    string str = (format(fmt) % 50 % 100).str();

 3、string_algo

string_algo是一个非常全面的字符串算法库，使用它需要包含头文件"boostalgorithmstring.hpp"，算法库的命名规范符合标准库的惯例：前缀i表示是大小写不敏感的，后缀_copy即为不改变原输入的copy版本，后缀_if表示使用一个谓词函数对象，很多算法都有包含这三个版本的函数，使用示例：

#include "boostalgorithmstring.hpp"

int main()
{
    string str("readme.txt");

    boost::to_upper(str);
    string strUpper = boost::to_lower_copy(str);

    bool bRet = boost::starts_with(str, "read");
    bRet = boost::iends_with(strUpper, "txt");
    bRet = boost::contains(str, "me");
    boost::all(str, boost::is_lower()); //判断每个字符是否都是小写
    boost::all(str, boost::is_alpha()); //判断每个字符是否都是字母
    boost::all(str, boost::is_digit()); //判断每个字符是否都是十进制数字
    boost::all(str, boost::is_alnum()); //判断每个字符是否都是字母或数字
    boost::all(str, boost::is_any_of("*+-")); //判断每个字符是否都是*或+或-

    boost::trim(str);
    boost::trim_if(str, boost::is_lower() || boost::is_digit());//清除两端小写的字符或数字
    boost::trim_left(str);

    str = "readme.txt";
    boost::iterator_range<string::iterator> rge; //boost::iterator_range相当于容器(string)的子区间类型，它有begin()、end()、size()、empty()等成员函数。
    rge = boost::find_first(str, "me"); //查找首次出现的位置
    if (rge/*!rge.empty()*/) //rge可以隐式转换为bool，所以有两种方法判断查找的结果
    {
        int iFoundPos = rge.begin() - str.begin(); //iFoundPos为4
        string strFind(rge.begin(), rge.end()); //strFind为"me"
        string strFull(rge.begin(), str.end()); //strFull为me.txt
        int a = 0;
    }
    boost::find_last(str, "txt"); //查找最后一次出现的位置
    boost::find_nth(str, "dm", 1); //查找"dm第二次出现的位置"

    str = "abc, TestD, test";
    vector<string> vs;
    boost::ifind_all(vs, str, "test"); //查找所有出现的位置
    for (auto obj : vs)
    {
        string s = obj;
        cout << s << ","; //输出为Test, test
    }
    vector<boost::iterator_range<string::iterator>> vr;
    boost::ifind_all(vr, str, "test");
    for (auto obj : vr)
    {
        string strSub(obj.begin(), obj.end());
        cout << strSub << ","; //输出为Test, test

        string strTemp(obj.begin(), str.end());
        cout << strTemp << ";"; //输出为TestD, test; test

        int iFoundPos = obj.begin() - str.begin();
        cout << iFoundPos << ","; //输出为5, 12
    }
    
    replace / erase_all(); //替换/删除所有出现的字符串
    replace / erase_first(); //替换/删除第一次出现的字符串
    replace / erase_last(); //替换/删除所有出现的字符串
    replace / erase_nth(); //替换/删除第n + 1次出现的字符串
    replace / erase_head(); //替换/删除开头的n个字符串
    replace / erase_tail(); //替换/删除结尾的n个字符串

    //split()以指定单个字符分割字符串到一个容器中，其参数列表的最后是一个带默认参数，取值可为token_compress_on、token_compress_off
    //token_compress_on表示连续两个分割字符出现时视为一个，token_compress_off为正常操作（会分割出一个空字符串来）。
    str = "c++ java c#";
    list<string> l;
    boost::split(l, str, boost::is_space()); //以空格分割
    auto it = l.begin();
    for (; it != l.end(); ++it)
    {
        string str = *it;
        cout << str << ","; //输出为c++, java, c#
    }

    std::vector<std::string> vc;
    boost::split(vc, str, boost::is_any_of(" ")); //以空格分割
    for (auto& item : vc)
　　 {
　　　　cout << item << ","; //输出为c++, java, c#,
　　 }


    struct SIs_space
    {
        bool operator()(const char& ch)const
        {
            return ch == ' ';
        }
    };
    list<boost::iterator_range<string::iterator>> lr;
    boost::split(lr, str, SIs_space());
    auto iter = lr.begin();
    for (; iter != lr.end(); ++iter)
    {
        string strSub(iter->begin(), iter->end());
        cout << strSub << ","; //输出为c++, java, c#

        string strTemp(iter->begin(), str.end());
        cout << strTemp << ";"; //输出为c++ java c#; java c#; c#

        int iFoundPos = iter->begin() - str.begin();
        cout << iFoundPos << ","; //输出为0, 4, 9
    }

    //使用分割迭代器来分割字符串，可以以多个字符来分割
    str = "Samus || samus || mario |||| Link";
    typedef boost::split_iterator<string::iterator> string_split_iterator;
    string_split_iterator p, endp;
    for (p = boost::make_split_iterator(str, boost::first_finder("||", boost::is_equal())); p != endp; ++p)
    {
        string strSub = string(p->begin(), p->end());
        //cout << strSub << ","; //输出为Samus , samus , mario ,, Link

        string strFull = string(p->begin(), str.end());
        cout << strFull << ","; //输出为 Samus || samus || mario |||| Link,  samus || mario |||| Link,  mario |||| Link, || Link, Link

        int iPos = p->begin() - str.begin();
        cout << iPos << ","; //输出为0, 8, 17, 26, 28
    }
    
    return 0;
}

 4、tokenizer

  使用tokenizer库可以很容易的执行分词操作，但它只支持使用单个字符进行分词，而且它对wstring(unicode)缺乏完善的考虑。通常建议使用string_algo或正则表达式来替换它的工作。

 5、xpressive

  xpressive是一个功能强大的正则表达式库，它比原正则表达式库boost.regex速度更快，而且不用编译。xpressive不仅是一个类似boost.regex的正则表达式解析器，还是一个类似于boost.spirit的语法分析器，并且将这两种不相交的文本处理方式融合在了一起。

  c++11中已经有了正则表达式类regex。