string algorithm 1

转载 2005年04月27日 17:40:00
简介

string algorithmboost中提供字符串算法的类库。在这里,字符串不一定是std::basic_string,也可以是其它的stl容器或是c++中的零结尾字符串char*

例:

std::string str("Hello");

std::vector<char> vstr(str.begin(), str.end());

char *cstr=new char(str.size());

std::copy(str.begin(), str.end(), cstr);

    

boost::to_upper(str);       //string

boost::to_upper(vstr);  //vector<char>

boost::to_upper(cstr);  //char*

 

另外,在string algorithm中的很多算法都分为mutable copymutable算法直接修改输入的字符串,而copy算法返回一个新的字符串或通过一个迭代器输出。

string algorithm中碰到一个IteratorRange的概念,这是boost::range中的一个类,我也不会使用,不过可以使用make_iterator_range(iterator, iterator)来构造。iterator_range通过两个开始和结束迭代器表示一段范围,一般通过查找算法的返回来得到。

例:

std::string str1("Hello");

std::string str2("Hello");

 

boost::to_upper(str1);//mutable algorithm,现在str1==”HELLO”

 

std::string str3=boost::to_upper_copy(str2);//copy algorithm, str3==”HELLO”

/*

char * p =boost::to_upper_copy("Hello");

这是错的。因为to_upper_copy不会去申请一段内存保存"Hello"的拷贝。

char str[]={"Hello"};

to_upper(str);这样这就可以了。

*/

    

std::string str4;

    

 

boost::to_upper_copy(std::back_inserter(str4),

                    std::make_pair(str2.begin(), str2.end())

                    );//使用迭代器的copy algorithm, str4==”HELLO”

                      //这里注意,这里和stl不同的是输出迭代器在输入迭代器的前面

boost::to_upper_copy(std::back_inserter(str4), "Hello");str4==”HELLOHELLO”

//这也是可以的,前面说过了IteratorRange相当于一个容器,

//stl标准容器,std::basic_string char*都可以作为string_algorithm中的容器

Case Conversion Algorithm 大小写转换算法

void           to_lower(MutableCollection&, std::local&=std::local());

void           to_upper(MutableCollection&, std::local&=std::local());

 

Sequence       to_lower_copy(const Sequence&, std::local&=std::local());

Sequence       to_upper_copy(const Sequence&, std::local&=std::local());

 

OutputIterator to_lower_copy(OutputIterator, const Collection&, std::local&=std::local());

OutputIterator to_lower_copy(OutputIterator, const Collection&, std::local&=std::local());

 

string algorithm中,Collection指:

l         stl标准类型

l         内建数组(如:int[])

l         零结尾字符串(char*wchar *)

l         pair<iterator, iterator>

MutableCollection当然是指非const collection

Sequence好像只能是标准容器。

 

Trim Algorithm Trim算法

void trim       (Sequence&, std::local&=std::local());

void trim_left  (Sequence&, std::local&=std::local());

void trim_right (Sequence&, std::local&=std::local());

 

Sequence trim_copy        (const Sequence&, std::local&=std::local());

Sequence trim_left_copy  (const Sequence&, std::local&=std::local());

Sequence trim_right_copy (const Sequence&, std::local&=std::local());

上述算法删除字符串中左右(或是其中之一)的空格。

 

void trim_if      (Sequence&, Predicate);

void trim_left_if (Sequence&, Predicate);

void trim_right_if(Sequence&, Predicate);

 

Sequence trim_copy_if      (const Sequence&, Predicate);

Sequence trim_left_copy_if (const Sequence&, Predicate);

Sequence trim_right_copy_if(const Sequence&, Predicate);

 

OutputIterator trim_copy_if      (OutputIterator, const Collection&, Predicate);

OutputIterator trim_left_copy_if (OutputIterator, const Collection&, Predicate);

OutputIterator trim_right_copy_if(OutputIterator, const Collection&, Predicate);

上述算法删除字符串左右(或是其中之一)满足Predicate的字符。

Predicate是一个一元判断式。

例:

string str(“---Hello---”);

boost::trim_if(str, bind2nd(equal_to<char>(), ’-‘));//str==”Hello”

 

Predicate 判断式

string algorithm中提供了一些与字符串相关的判断式。

bool starts_with (Input, Test);

bool starts_with (Input, Test, Comp)

bool istarts_with(Input, Test, Local)

判断Input是否以Test开头。Comp是比较字符的二元判断式。Localstd::local

 

bool ends_with (Input, Test);

bool ends_with (Input, Test, Comp)

bool iends_with(Input, Test, Local)

判断Input是否以Test结尾。Comp是比较字符的二元判断式。Localstd::local

 

bool contains (Input, Test);

bool contains (Input, Test, Comp)

bool icontains(Input, Test, Local)

判断Input是否包含TestComp是比较字符的二元判断式。Localstd::local

 

bool equals (Input, Test);

bool equals (Input, Test, Comp)

bool iequals(Input, Test, Local)

判断Input是否和Test相同。Comp是比较字符的二元判断式。Localstd::local

 

bool all(Input, Pred);

判断Input的每一个字符是否满足Pred判断式。

 

Classfication 类别判断式

classfication也是判断式,它们是对std::isspace等函数的泛型化封装。

unspecified is_classified(std::ctype_base::mask, const std::locale & = std::locale());

unspecified is_space      (const std::locale & = std::locale());

unspecified is_alnum      (const std::locale & = std::locale());

unspecified is_alpha      (const std::locale & = std::locale());

unspecified is_cntrl      (const std::locale & = std::locale());

unspecified is_digit      (const std::locale & = std::locale());

unspecified is_graph      (const std::locale & = std::locale());

unspecified is_lower      (const std::locale & = std::locale());

unspecified is_print      (const std::locale & = std::locale());

unspecified is_punct      (const std::locale & = std::locale());

unspecified is_upper      (const std::locale & = std::locale());

unspecified is_xdigit     (const std::locale & = std::locale());

判断字符是否是某个类型,返回判断式。

例:

trim_copy_if(string(“123Hello890”, is_digit()));//return “Hello”

 

unspecified is_any_of(Set);

判断字符是否是Set中的一个,返回判断式。

 

unspecified is_from_range(From, To);

判断字符是否是否处在FromTo之间(From<=Ch<=To)

 

unspecified operator&&(Pred1, Pred2);

unspecified operator||(Pred1, Pred2);

unspecified operator!(Pred);

classfication判断式的与或非运算。注意:只能对上述的classfication判断式使用。

例:

trim_copy_if(string(“123Hello890”), is_digit()||is_upper());//return “ello”

 

iterator_range Class 迭代器范围类

iterator_range是对一组迭代器的封装。一般用于find算法的返回值。

iterator_range有类似于stl容器的begin(), end(), empty(), size(), swap(), bool operator()成员函数。

一般使用make_iterator_range()来构造iterator_rangmake_iterator_range使用两个迭代器或者是pair<iterator, iterator>作为参数。

还可以使用流来输出iterator_range

例:

string str(“Hello”);

cout<<make_iterator_range(str.begin()+1, str.end()-1);//output “ell”

对于iterator_rangeostream输出类似于 copy(it.begin(),it.end(),ostream_iterator<char>(“”));

无空格的连续输出。

Erase Algorithm 删除算法

OutputIterator erase_range_copy (OutputIterator, Input, SearchRange);

Sequence       erase_range_copy (Input, SearchRange);

 

void           erase_range       (Input, SearchRange);

删除输入字符串中SearchRange那部分。SearchRange是一个iterator_range对象。

例:

std::string str1("Hello");

std::string str2;

    

boost::erase_range(str1, boost::make_iterator_range(str1.begin()+1, str1.end()-1));

cout<<str1<<endl;//输出”Ho”

 

erase_range_copy(back_inserter(str2),

                    str1,

                    boost::make_iterator_range(str1.begin()+1, str1.end()-1));

cout<<str2<<endl;//输出”Ho”

 

OutputIterator erase_first_copy(OutputIterator, Input, Search);

Sequence       erase_first_copy(Input, Search);

void           erase_first     (Input, Search);

 

OutputIterator ierase_first_copy(OutputIterator, Input, Search, Local);

Sequence       ierase_first_copy(Input, Search, Local);

void           ierase_first     (Input, Search, Local);

删除从Input中查找到的第一个Search

例:

std::string str1("Hello");

std::string str2;

 

boost::erase_first(str1, "ll");

str2=boost::erase_first_copy(string("Hello"), "l");

cout<<str1<<endl;//输出”Heo”

cout<<str2<<endl;//输出”Helo”

 

OutputIterator erase_last_copy(OutputIterator, Input, Search);

Sequence       erase_last_copy(Input, Search);

void           erase_last     (Input, Search);

 

OutputIterator ierase_last_copy(OutputIterator, Input, Search, Local);

Sequence       ierase_last_copy(Input, Search, Local);

void           ierase_last     (Input, Search, Local);

删除从Input中查找到的最后一个Search

 

OutputIterator erase_nth_copy(OutputIterator, Input, Search, n);

Sequence       erase_nth_copy(Input, Search, n);

void           erase_nth      (Input, Search, n);

 

OutputIterator ierase_nth_copy(OutputIterator, Input, Search, n, Local);

Sequence       ierase_nth_copy(Input, Search, n, Local);

void           ierase_nth     (Input, Search, n, Local);

删除从Input中查找到的第nSearch。(n是基于0的)

 

OutputIterator erase_all_copy(OutputIterator, Input, Search);

Sequence       erase_all_copy(Input, Search);

void           erase_all     (Input, Search);

 

OutputIterator ierase_all_copy(OutputIterator, Input, Search, Local);

Sequence       ierase_all_copy(Input, Search, Local);

void           ierase_all     (Input, Search, Local);

删除从Input中查找到的所有Search

 

OutputIterator erase_head_copy (OutputIterator, Input, n);

Sequence       erase_head_copy (Input, n);

void           erase_head     (Input, n)

删除Input的前n个字符。如果n大于输入字符串长度,那么整个字符串会被删除。

 

OutputIterator erase_tail_copy (OutputIterator, Input, n);

Sequence       erase_tail_copy (Input, n);

void           erase_tail      (Input, n);

删除Input的最后n个字符。如果n大于输入字符串长度,那么整个字符串会被删除。

 

Replace Algorithm 替换算法

OutputIterator replace_range_copy (OutputIterator, Input, SearchRange, Format);

Sequence       replace_range_copy (Input, SearchRange, Format);

void           replace_range      (Input, SearchRange, Format);

Input中的SearchRange部分替换成Format

 

OutputIterator replace_first_copy (OutputIterator, Input, Search, Format);

Sequence       replace_first_copy (Input, Search, Format);

void           replace_first      (Input, Search, Format);

 

OutputIterator ireplace_first_copy (OutputIterator, Input, Search, Format, Local);

Sequence       ireplace_first_copy (Input, Search, Format, Local);

void           ireplace_first      (Input, Search, Format, Local);

Input中搜索到的第一个Search替换成Format

 

OutputIterator replace_last_copy (OutputIterator, Input, Search, Format);

Sequence       replace_last_copy (Input, Search, Format);

void           replace_last      (Input, Search, Format);

 

OutputIterator ireplace_last_copy (OutputIterator, Input, Search, Format, Local);

Sequence       ireplace_last_copy (Input, Search, Format, Local);

void           ireplace_last      (Input, Search, Format, Local);

Input中搜索到的最后一个Search替换成Format

 

OutputIterator replace_nth_copy (OutputIterator, Input, Search, Format, n);

Sequence       replace_nth_copy (Input, Search, Format, n);

void           replace_nth      (Input, Search, Format, n);

 

OutputIterator ireplace_nth_copy (OutputIterator, Input, Search, Format, n, Local);

Sequence       ireplace_nth_copy (Input, Search, Format, n, Local);

void           ireplace_nth      (Input, Search, Format, n, Local);

Input中搜索到的第nSearch替换成Format

 

OutputIterator replace_all_copy (OutputIterator, Input, Search, Format);

Sequence       replace_all_copy (Input, Search, Format);

void           replace_all      (Input, Search, Format);

 

OutputIterator ireplace_all_copy (OutputIterator, Input, Search, Format, Local);

Sequence       ireplace_all_copy (Input, Search, Format, Local);

void           ireplace_all      (Input, Search, Format, Local);

Input中所有的Search替换成Format

 

OutputIterator replace_head_copy(OutputIterator, Input, n, Format);

Sequence       replace_head_copy(Input, n, Format);

void           replace_head     (Input, n, Format);

Input中前n个字符替换成Format

 

OutputIterator replace_tail_copy(OutputIterator, Input, n, Format);

Sequence        replace_tail_copy(Input, n, Format);

void             replace_tail      (Input, n, Format);

Input中最后n个字符替换成Format

 

Finder Object Finder仿函数

Finder Object是一个仿函数,它用来决定在find算法中的匹配策略。可以在find_iterator中使用。

Finder first_finder(Search);

Finder first_finder(Search, Comp);

返回在输入中查找第一个SearchFinder对象。

 

Finder last_finder(Search);

Finder last_finder(Search, Comp);

返回在输入中查找最后一个SearchFinder对象。

 

Finder nth_finder(Search, n);

Finder nth_finder(Search, n, Comp);

返回在输入中查找第一个SearchFinder对象。

 

Finder head_finder(n);

Finder tail_finder(n);

返回在输入中查找最前(后)n个字符的Finder对象。(n是基于0的)

 

Finder token_finder(Pred, Compress= token_compress_off);

返回满足Pred判断式的字符的查找的Finder对象。

Pred 是类似于bool pred(char c);这样的函数或仿函数。

Compress可以取值为:

token_compress_on :将相邻的满足Pred的字符合并作为查找结果。

token_compress_off:不合并相邻的字符。

例如:对于bind2nd(equal_to<char>,’c’)这样的判断式,用token_finder查找”aabbcc”,对于token_compress_on结果是”cc”,对于token_compress_off是分别查找到两个”c”

 

Finder range_finder(beg, end);

Finder range_finder(iterator_range);

返回查找特定范围的Finder对象。

Find算法

Find算法是在字符串中查找子串的算法,算法返回iterator_range类型。

iterator_range find(Input, Finder);

iterator_range find_first(Input, Search);

iterator_range ifind_first(Input, Search,Local=std::local());

iterator_range find_last(Input, Search);

iterator_range ifind_last(Input, Search, Local=std::local());

iterator_range find_nth(Input, Search, n);

iterator_range ifind_nth(Input, Search, n, Local=std::local());

iterator_range find_head(Input, n);

iterator_range find_tail(Input, n);

iterator_range find_token(Input, Pred, Compress= token_compress_off);

上述的算法都很简单,我就不多说了。

我来分析一下find_firstfind_first的源代码是这样的:

template<typename Collection1T, typename Collection2T>

        inline iterator_range<

            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>

        find_first(

            Collection1T& Input,

            const Collection2T& Search)

        {

            return first_finder(Search)(

                begin(Input),end(Input));

        }

result_iterator_of<Collection1T>::typeCollection1T::iterator

begin(Input)Input.begin()

end(Input)Input.end()

first_finder(Search)返回一个first_finder对象,然后调用这个Finder.operator()(beg,end),并且以iterator_range作为查找结果返回。其实对于每一个Finder都重载了operator()函数,使用这个函数就可以对字符串直接查找。

 

Find Iterator 查找迭代器

find算法只能查找到一个结果,而通过find_iterator可以查找所有的结果。

template<typename Iterator> class find_iterator;

find_iterator make_find_iterator(Input, Finder);

find_iterator的成员函数:

  find_iterator()默认构造函数

  find_iterator(beg, end, Finder)begend之间查找

  find_iterator(Input, Finder)查找Input

 

  bool eof()是否查找结束

例:

std::string str1("ten 10 nine 9 and eight 8");

 

boost::find_iterator<string::iterator> it;

for (it = make_find_iterator(str1,

                                  token_finder(boost::is_digit(),

                                                 boost::token_compress_on)//查找连续数字的token_finder

                                 )

         ;!it.eof();++it)//注意是it.eof()it->意味着(*it). *it是一个iterator_range对象

        cout<<*it<<endl;//*it返回查找结果:一个iterator_range对象,而一个iterator_range是可以直接输出的。

//输出:

//10

//9

//8

 

在使用find_iterator的过程中,不能修改字符串的长度,例如:erase_range(str1,*it)如果是replace就可以。

另外,find_iteratorForward迭代器,不能--it

 

template<typename Iterator> class split_iterator;

find_iterator make_split_iterator(Input, Finder);

split_iterator使用查找到的字串来分隔字符串,例如对于上述例子,用split替换find,结果是:

ten

 nine

 and eight

 

splite_iterator的其它用法和find_iterator一样。

2016 UESTC Training for Search Algorithm & String A - Xiper的奇妙历险(1) 八皇后问题、dfs

八皇后问题 这里是九个皇后 逐行放置,则皇后肯定不会横向攻击,只需要检查纵向和两个斜向攻击即可 其中用 cur - C[cur] == j - C[j] || cur + C[cur] == j + ...

Algorithm: String (1) 特殊的题目

6. ZigZag Conversion 68. Text Justification 71. Simplify Path 214. Shortest Palindrome S...

Learning boost 3 -- string algorithm 1

Learning boost 3 string algorithm 1 简介 string algorithm是boost中提供字符串算法的类库。在这里,字符串不一定是std::ba...
  • liwf616
  • liwf616
  • 2014年02月08日 16:52
  • 595

【Search&String Algorithm Training】Xiper的奇妙历险(1)

【Search&String Algorithm Training】 - A URL:http://acm.uestc.edu.cn/#/problem/show/1378 西历77200...

Algorithm_String: 字符串与EditText_01

虽然使用java来开发android的应用层,但是与Java的有些东西还是有所出入。 本篇博客结合android的EditText与String类的方法,希望能在开发中帮助到你。 这篇博客您可以了...

分隔和截断字符串, boost string algorithm library中的split和trim

http://www.boost.org/doc/libs/1_46_1/doc/html/string_algo.html 这个库是个 headers only library  这个库提供了...

2016 UESTC Training for Search Algorithm & String K - 卿大爷的三个女友 KMP、跳转数组

KMP 的跳转数组的拓展使用 关键在于KMP思维的转化。思维很重要!先用文本串做个跳转数组。 设文本串长度为len。 我们考虑匹配第len个位置。跳转数组每跳一个位置。 都能保证文本串的前缀==后缀,...

【Search&String Algorithm Training】Xiper的奇妙历险(2)

【Search&String Algorithm Training】- B 三维迷宫 转眼间,已经过了10年。 Xiper 和日天都以优异的成绩,从UESTC毕业了。 毕业之后,Xiper 每天勤奋...

【Search&String Algorithm Training】谭爷剪花布条

【Search&String Algorithm Training】- I “对不起,你是个好人...” 手上的玫瑰花缓缓掉落,谭爷看着妹子远去的背影,呆呆地站着。 “我怎么就把不到妹子...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:string algorithm 1
举报原因:
原因补充:

(最多只允许输入30个字)