爱华网Boost.Tokenizer用容器的表现形式将一个字符串或其它字符序列分解为一系列单词（Token）
所需头文件:
分解例子
typedefboost::tokenizer<boost::char_separator<char>> Token;
boost::char_separator<char> sep(",;");
std::string str("1 2 3 4 5 ; 6, 7");
Token tok(str, sep);
Token::iterator it = tok.begin();
for (; it != tok.end(); ++it)
{
TRACE("n%s", it->c_str());
}
#include<boost/tokenizer.hpp>
示例代码：
// simple_example_1.cpp
#include<iostream>
#include<boost/tokenizer.hpp>
#include<string>
int main(){
using namespacestd;
using namespaceboost;
string s = "This is, atest";
tokenizer<>tok(s);
for(tokenizer<>::iteratorbeg=tok.begin(); beg!=tok.end();++beg){
cout << *beg<< " ";
}
}
boost::tokenizer的外观表现为一个保存单词的容器，通过访问它的迭代器就可得到分解后的单词。说它“表现”为一个容器的原因是它并不象vector之类的容器那样一开始就储存了一堆单词，而是在访问它的迭代器时才开始分解源序列（不仅仅是字符串哦）。
它的类声明为：
template <
classTokenizerFunc =char_delimiters_separator<char>,
classIterator = std::string::const_iterator,
class Type =std::string
>class tokenizer;
模板参数描述
TokenizerFunc用于分解序列，见后文
Iterator访问该序列的迭代器类型。
Type单词的类型，通常是std::string。
boost::tokenizer的构造函数使用两种方式接收输入数据：容器和迭代器
//使用容器
template<classContainer>
tokenizer(const Container& c,constTokenizerFunc& f =TokenizerFunc());
//使用迭代器
tokenizer(Iterator first, Iterator last,constTokenizerFunc& f = TokenizerFunc());
这里的容器不一需要一定是string,也可以是任何表现为字符容器的类，同样迭代器也可以很自由，如下例:
#include<iostream>
#include<boost/tokenizer.hpp>
#include<list>
int main(){
usingnamespace std;
usingnamespace boost;
char s[] ="This is, a test";
//分解list容器里的字符
{
list<char> vec_s(s,s+strlen(s));
typedef tokenizer<
char_delimiters_separator<char>,
list<char>::const_iterator//使用list的迭代器
> listtok;
listtok tok(vec_s);
for(listtok::iterator beg=tok.begin();beg!=tok.end();++beg){
cout << *beg<< " ";
}
}
//分解从控制台读入的字符串
{
//输入流迭代器
typedef istream_iterator<char,char>initer;
typedef tokenizer<
char_delimiters_separator<char>,
initer//使用输入流迭代器
> cintok;
cin >> noskipws;//不跳过空格
cintok tok = cintok( initer(cin), initer());
for(cintok::iterator beg=tok.begin(); beg!=tok.end();++beg){
cout << *beg<< " ";
}
}
return0;
}
细说TokenizerFunction参数
TokenizerFunction是一个函数对象，其目的是分析一个给定的序列，直至找到一个单词或到达序列末尾。然后它更新该单词，并通知调用者当前单词之后的下一个字符的位置。
对于tokenizer来说，它只关心TokenizerFunction里的两个 方法，一个当然是函数对象一定有的operator()，另一个是reset()。
operator()的作用是从序列中取出下一个单词，tokenizer的 迭代器前进一次就会调用一次，其定义如下：
template <typename InputIterator, typenameToken>
bool operator()(InputIterator&
next, InputIterator end,Token&tok);由tokenizer调用时，模板类型InputIterator和Token被特化为tokenizer::Iterator和tokenizer::Type(见tokenizer类声明)。
参数描述
next,end这是一对迭代器，用于访问序列中的字符，其中的next在调用完成后应该指向当前单词后的下一字符。
tok存放分解出的单词。
bool返回值 返回值为true时表明tok有效，否则表示已经到序列尾部或解析出错。
reset()定义如下
void reset()它在每次分析序列之前调用，一般用于重置一些状态变量。
要自己定义一个TokenizerFunction用 于tokenizer还必须 确保它可赋值和可拷贝（即operator=和拷贝构造必须可用）
下例中我们自定义了一个函数对象作为tokenizer的TokenizerFunction参数:
#include<iostream>
#include<boost/tokenizer.hpp>
#include<string>
//自定义一个separator，分解指定分隔符的序列
struct my_separator
{
//一般用于重置一些状态变量，这里用不上
void reset(){ }
template<typename InputIterator, typenameToken>
booloperator()(InputIterator& next, InputIterator end,Token& tok)
{
//存放单词的，一般应该是一个string(见tokenizer::Type模板参数)
tok = Token();
//找到有效位置
for (;next != end && *next ==m_sep;++next);
//到结尾返回false
if (next == end) return false;
//取出单词
for (;next != end && *next !=m_sep; ++next)
{
tok += *next;
}
return true;
}
//构造函数，指定分隔符
my_separator(char c)
:m_sep(c){;}
private:
charm_sep;
};
int main()
{
usingnamespace std;
usingnamespace boost;
string s ="Thi|s is,| a| |tes|t";
//指定'|'作为分隔符
tokenizer<my_separator> mytok(s,my_separator('|'));
for(tokenizer<my_separator>::iteratorbeg=mytok.begin(); beg!=mytok.end(); ++beg)
{
cout << '<'<< *beg<< ">";
}
return0;
}
其实大部分情况我们并不需要自己写TokenizerFunction，Boost.Tokenizer帮我们准备好的几个TokenizerFunction足以满足大部分需要，下面是这些TokenizerFunction的介绍：
char_delimiters_separator
默认参数，以标点符号各空格字符作为分隔符
它的构造函数如下：
char_delimiters_separator(bool return_delims = false,
const Char*returnable = 0,
const Char*nonreturnable = 0);
参数描述
return_delims是否返回发现的分隔符。注意不是所有分隔符都可返回。有关解释请见其它两个参 数。
returnable指定可返回的分隔符。这些分隔符当 return_delims 为 true 时将作为单词返回。由于这通常是标点符号，所以如果以 0作为该参数提供，则可返回分隔符将是所有使 std::ispunct(C) 为 true 的 C. 如果该参数为 "",则代表没有可返回分隔符。
nonreturnable指定不可返回的分隔符。这些分隔符不可作为单词返回。由于这通常是空白字符，所以如果该参数为 0，则不可返回分隔符将是所有使std::isspace(C) 为 true 的C. 如果该参数为 "", 则代表没有不可返回的分隔符。
区别不可返回和可返回分隔符的原因是，有些分隔符仅用作分隔单词而没有更多的意义。以字符串 "b c +"为例。假设你在写一个简单的计算器，分析后缀形式的表达式。空格和加号都可以用作分隔单词，你只对加号感兴趣而对空格不感兴趣。将空格作为单词返回只会使你的代码复杂化。这时你需要指定加号为可返回分隔符，而空格为不可返回分隔符。
char_separator
由指定的字符作为分隔符
它的构造函数如下：
char_separator(const Char* dropped_delims,
const Char*kept_delims = 0,
empty_token_policy empty_tokens = drop_empty_tokens);
参数描述
dropped_delims以字符串的形式指定多个可返回分隔符
kept_delims以字符串的形式指定多个不可返回分隔符
empty_tokens当在输入序列中出现两个连续的分隔符时，是否要输出一个空白单词或是直接跳过。
empty_tokens可以是drop_empty_tokens(跳过)或keep_empty_tokens(输出空白单词)
例：
#include<iostream>
#include<boost/tokenizer.hpp>
#include<string>
int main()
{
std::stringstr = ";;Hello|world||-foo--bar;yow;baz|";
typedefboost::tokenizer<boost::char_separator<char>>
tokenizer;
boost::char_separator<char> sep("-;","|", boost::keep_empty_tokens);
tokenizertokens(str, sep);
for(tokenizer::iterator tok_iter =tokens.begin();
tok_iter != tokens.end(); ++tok_iter)
std::cout << "<"<< *tok_iter<< ">";
std::cout<< " ";
returnEXIT_SUCCESS;
}
输出结果：
<> <><Hello><|><world><|> <><|> <><foo><><bar><yow><baz><|><>
escaped_list_separator
对csv (逗号分隔)格式进行分解，并支持转义符
它的构造函数如下：
escaped_list_separator(Char e = '\', Char c = ',',Char q ='"');
escaped_list_separator(string_type e, string_type c, string_typeq);这两个构造函数的区别是第一个只能指定一个字符作为分隔符，而第二个可以指定多个。
参数 描述
e指定转义符字符，默认是反斜杆''
c指定分隔符字符，默认是逗号','
q指定作为引号的字符，默认是引号'"'
参数e指定的转义符与C语言中的转义符一样，如果单词中含有分隔符，可以用引号包起来。如果单词中又有分隔符又有引号，则需要使用转义符：
转义序列结果
<转义符><引号><引号>
<转义符>n换行
<转义符><转义符><转义符>
例：
#include<iostream>
#include<boost/tokenizer.hpp>
#include<string>
int main()
{
usingnamespacestd;
usingnamespace boost;
string s ="Field 1,"putting quotes a\"round fields, allows commas",Field3";
tokenizer<escaped_list_separator<char>> tok(s);
for(tokenizer<escaped_list_separator<char>>::iterator
beg=tok.begin(); beg!=tok.end();++beg)
{
cout << *beg<< " ";
}
returnEXIT_SUCCESS;
}
输出结果：
Field1
putting quotes a"round fields, allows commas
Field3
offset_separator
偏移分隔符，按偏移量将一个字符序列分解为多个字符串
构造函数如下：
template<typename Iter>
offset_separator(Iter begin,
Iter end,
bool bwrapoffsets = true, bool breturnpartiallast = true);
参数描述
begin,end指定整数偏移量序列
bwrapoffsets指明当所有偏移量用完后是否回绕到偏移量序列的开头继续。例如字符串 "1225200101012002" 用偏移量 (2,2,4)分解，如果bwrapoffsets为 true, 则分解为 12 25 2001 01 01 2002. 如果 bwrapoffsets 为 false, 则分解为12 25 2001，然后就由于偏移量用完而结束。
breturnpartiallast 指明当被分解序列在生成当前偏移量所需的字符数之前结束，是否创建一个单词，或是忽略它。例如字符串"122501" 用偏移量 (2,2,4) 分解，如果 breturnpartiallast 为 true，则分解为 12 2501. 如果为 false, 则分解为 1225，然后就由于序列中只剩下2个字符不足4个而结束。
使用这个类时，将它的某个对象传入到任何需要 TokenizerFunction的地方。如果该对象是缺省构造的，则被分解序列中的每个字符将被作为一个单词返回(即缺省值为偏移量 1, 且 bwrapoffsets 为true)。
例：
// simple_example_3.cpp
#include<iostream>
#include<boost/tokenizer.hpp>
#include<string>
int main(){
usingnamespace std;
usingnamespace boost;
string s ="12252001";
intoffsets[] = {2,2,4};
offset_separator f(offsets, offsets+3);
tokenizer<offset_separator>tok(s,f);
for(tokenizer<offset_separator>::iterator
beg=tok.begin(); beg!=tok.end();++beg){
cout << *beg<< " ";
}
}
Tokenizer迭代器
boost::tokenizer的主要功能都集中在它的迭代器中，我们甚至可以直接使用tokenizer的迭代器来处理序列。
通过make_token_iterator来产生创建迭代器：
template<class Type, class Iterator, classTokenizerFunc>
typenametoken_iterator_generator<TokenizerFunc,Iterator,Type>::type
make_token_iterator(Iterator begin, Iterator end,constTokenizerFunc& fun);
参数描述
begin被分析序列的开始
end被分析序列的末尾
fun某个符合 TokenizerFunction 的函数对象
迭代器的类型由token_iterator_generator::type来取得，token_iterator_generator的定义为
template <
class TokenizerFunc =char_delimiters_separator<char>,
class Iterator = std::string::const_iterator,
class Type = std::string
>
class token_iterator_generator;
模板参数描述
TokenizerFunc用于分析序列的 TokenizerFunction.
Iterator用于指定序列的迭代器类型。
Type单词的类型，通常为 string.
例子
/// simple_example_5.cpp
#include<iostream>
#include<boost/token_iterator.hpp>
#include<string>
int main()
{
using namespace std;
using namespace boost;
string s = "12252001";
int offsets[] = {2,2,4};
offset_separator f(offsets, offsets+3);
typedeftoken_iterator_generator<offset_separator>::typeIter;
Iter beg =make_token_iterator<string>(s.begin(),s.end(),f);
Iter end =make_token_iterator<string>(s.end(),s.end(),f);
// 上面这行语句也可以这样写：
// Iter end;
for(;beg!=end;++beg){
cout << *beg<< " ";
}
}
