Tag: 算法

字符串算法我们说来也好几讲的内容来，剩下的已经不多又或者是我们没有必要再一一例举，那么这一讲我们就来结束关于boost::algorithm::string剩下的一些内容。

判断一个字符属于什么类型这些小工具boost::algorithm::string自然也是有提供来的，比如：

//================================================

is_space : //字符是空格或者是制表符

is_alnum : //字符是字母或者数字字符

is_alpha : //字符是否为字母

is_cntrl : //字符是否为控制字符

is_digit : //字符是否为十进制数字

is_xdigit : //字符是否为十六进制数字

is_graph : //字符是否为图形字符

is_lower : //字符是否为小写字符

is_upper : //字符是否为大写字母

is_print : //字符是否为可打印字符

is_any_of : //字符是否为参数中的任意字符

is_from_rang : //字符是否在指定范围之内

//===============================================

除来这些分类函数之外，自然也和我们说过的MString一样拥有start_with ,end_with，他们同样有i开头的版本，i开头的自然是不区分大小写的比较，同样也有修剪系列函数，他们的功能和我们说过的MString的修剪函数一样，而且名字也一样，trim_left，trim_right，trim，他们也有带有_copy后最的版本，但是boost里面的却还有_if的版本，他们需要一个函数对象或者能够作为判断式的函数指针，我们甚至可以认为非_if的版本是_if后缀版本的特殊情况。

除来上面这些还有一些有用的函数，比如contains，该函数判断一个字符串中是否包含指定字符串，equals判断两个字符串是否相等，lexicographical_compare函数用于根据字典顺序判断第一个字符串是否小于第二个字符串，当然这些函数也拥有i前缀的版本，这些函数可以说在实际开发过程中是相当有用的。

//================================================

if (boost::algorithm::is_digit()(48)){

std::cout <<"

48 is digit"

<<std::endl;

}

else{

std::cout <<"

48 isn't digit"

<<std::endl;

}

if (boost::algorithm::is_xdigit()(75)){

std::cout <<"

75 is xdigit"

<<std::endl;

}

else{

std::cout <<"

75 isn't xdigit"

<<std::endl;

}

if (boost::algorithm::is_cntrl()(13)){

std::cout <<"

13 is cntrl "

<<std::endl;

}

else{

std::cout <<"

13 isn't cntrl "

<<std::endl;

}

if (boost::algorithm::is_print()(13)){

std::cout <<"

13 is print "

<<std::endl;

}

else{

std::cout <<"

13 isn't print "

<<std::endl;

}

if (boost::algorithm::is_alnum()(70)){

std::cout <<"

70 is alnum "

<<std::endl;

}

else{

std::cout <<"

70 isn't alnum "

<<std::endl;

}

if (boost::algorithm::is_any_of("

abcdefg"

)(67)){

std::cout <<"

67 is is_any_of(acbdefg)"

<<std::endl;

}

else{

std::cout <<"

67 isn't is_any_of(acbdefg)"

<<std::endl;

}

if (boost::algorithm::is_from_range(67, 90)(70)){

std::cout <<"

70 is is_from_range(67,90)"

<<std::endl;

}

else{

std::cout <<"

70 isn't is_from_range(67,90)"

<<std::endl;

}

std::string str("

Hello World Hello Hello"

);

assert(boost::algorithm::istarts_with(str, "

hello"

));

//不区分大小写

assert(boost::algorithm::starts_with(str, "

Hello"

));

//区分大小写

assert(boost::algorithm::iends_with(str, "

hello"

));

//不区分大小写

assert(boost::algorithm::ends_with(str, "

Hello"

));

//区分大小写

str = "

Hello "

;

boost::algorithm::trim(str);

// 将前后空格去掉

assert(boost::algorithm::equals(str, "

Hello"

));

assert(boost::algorithm::iequals(str, "

hello"

));

//======================================

这里就列举这些，其他的大家按照上面的方法来试着怎么用吧。

关于字符串的操作的，只要熟练使用来这些就基本足够应付各种问题来，如果要遇到这些都无法满足的情况，那么就开大招——使用正则表达式吧。大家可以预先去了解一下正则表达式的东西，因为我们可能不在课堂上给大家介绍正则表达式怎么写，这里只会告诉大家怎么使用C++中的正则表达式。

//=============================================

回复D或者d查看目录，回复阿拉伯数字查看相应章节

原文始发于微信公众号（

C/C++的编程教室

）：第118讲 boost::algorithm::string之其他

|

在boost的字符串算法中，关于分割的函数应该是有2个的，还记得我们在115讲里面说到的find_all吗？从某些角度来说这也算是一种分割方式，只是这比较特殊一些，所有的结果都是一样的而已，那么这一讲我们来说一个一般的分割，其实关于分割大家都比较清楚的了，简单点说就是将一个字符串按照某种方式将他分成N多段，这种对字符串的操作通常很有用，在实际项目中对字符串的处理可以说是随处可见，而分割字符串更是家常便饭了，那么说了这么多废话，我们来点实际的东西。

//==========================================

template<typename SequenceSequenceT, typename RangeT, typename PredicateT >

inline SequenceSequenceT&

split(

SequenceSequenceT&

Result,

RangeT&

Input,

PredicateT Pred,

token_compress_mode_type eCompress=token_compress_off )

//==========================================

这就是split的函数声明，SequenceSequenceT可以是vector，deque，list等标准容器，对Input的要求也没那么多，通常于我们来说只要是string或者是boost::iterator_range<std::string::iterator>即可，当然我们通常都是对string进行处理的，所以这我们就不关心了，PredicateT是一个判断式，可以理解为一个函数对象，因为这里是当以当前字符为参数时返回true的话那么当前点就是一个分割点，我们不用纠结这东西，boost本身就提供有一个已经很完备的判断式了:is_any_of,我们只需要将我们要分割的东西给他就行，看下面的例子就知道。在结果中分割字符串是要被丢弃的。token_compress_mode_type 这个参数的目的简单点说就是这种形式 :: ，这里是当作两个:号来处理呢还是就是:号来处理？嗯，这句话说得不清不楚，还好在程序有时候比语言的表述来更直接一些：

//=========================================

string str("

Hello :::::: World"

);

vector<string>result;

split(result,str,is_any_of("

:"

));

// 使用空格和:来进行分割

// 这里会得到结果是 "

Hello"

"

"

"

"

"

"

"

"

"

"

"

"

"

"

"

World"

result.clear();

split(result, str, is_any_of("

:"

),token_compress_on);

// 使用空格和:进行分割

// result : "

Hellow"

"

World"

//========================================

还是代码来得实在一些，简单两句代码就将一些于我来说很难用语言来描述的现象给解释清楚了，从上面的函数原型里面我们看到split的最后一个参数是有默认值的，那就是token_compress_off，这就是不压缩处理，而我们开启压缩处理后，那些:::::都被当成一个:,有因为空格和:都是连在一起的，而空格也是被定义为分隔符，所以也都被压缩在一起进行处理了。于是乎我们就得到了想要的Hellow World了。

和split相对的是join，顾名思义，这就是将字符串连接起来，所以他的用法很简单，不过他有两个版本，一个带有_if后缀的版本，这自然是需要一个判断式，只有满足判断式的字符串才会被添加到链接队列之中，我们来看看他们的用法：

//==========================================

std::string str("

Hello,World,Ni,Hao,A"

);

std::vector<std::string>v_str;

boost::algorithm::split(v_str, str, boost::algorithm::is_any_of("

,"

),boost::algorithm::token_compress_on);

// 将字符串按照，号进行分割

std::string __str = boost::algorithm::join(v_str, "

—"

);

// 再将字符串重新连接起来

// Hello—World—Ni—Hao–A

std::string __str2 = boost::algorithm::join_if(v_str, "

—"

, [&

](const std::string&

s){

return boost::algorithm::contains(s, "

l"

);

});

// 只连接包含l字符的字符串

// 结果为Hello—World

//=========================================

不论是split还是join，他们都是对字符串进行处理，那么很多时候我们可能想要的不是字符串，有可能是其他的东西，比如是数字等等，为了解决这个问题，我们可以对split和join进行扩展（可以参考我们前面说的MString，他们可以转变为任意类型的东西)。

//========================================

template<typename T,typename A,template<typename T1,typename A1>class C>

void __split(C<T, A>&

result, const std::string&

input,const std::string&

spliter,bool isPress = false){

result.clear();

if (input.empty())

return;

std::vector<std::string>__result;

boost::algorithm::token_compress_mode_type __type;

if (isPress)

__type = boost::algorithm::token_compress_on;

else

__type = boost::algorithm::token_compress_off;

boost::algorithm::split(__result, input, boost::is_any_of(spliter), __type);

for (auto&

t : __result){

try{

T __t = boost::lexical_cast<T>(t);

result.push_back(__t);

}

catch (boost::bad_lexical_cast e){

;

}

}

}

//=================================

// 针对string进行特化

//=================================

template<typename A, template<typename T1, typename A1>class C>

void __split(C<std::string, A>&

result, const std::string&

input, const std::string&

spliter, bool isPress = false){

result.clear();

if (input.empty())

return;

std::vector<std::string>__result;

boost::algorithm::token_compress_mode_type __type;

if (isPress)

__type = boost::algorithm::token_compress_on;

else

__type = boost::algorithm::token_compress_off;

boost::algorithm::split(result, input, boost::is_any_of(spliter), __type);

}

template<class T,class A,template<class T1,class A1>class C>

std::string __join(const C<T, A>&

Input, const std::string&

joiner){

std::vector<std::string>__v_str;

for (auto&

c : Input){

try{

std::string str = boost::lexical_cast<std::string>(c);

__v_str.push_back(str);

}

catch (boost::bad_lexical_cast e){

;

}

}

return boost::join(__v_str, joiner);

}

//==================================================

// 同样需要针对string进行特化

//==================================================

template<class A, template<class T1, class A1>class C>

std::string __join(const C<std::string, A>&

Input, const std::string&

joiner){

return boost::join(Input, joiner);

}

//=========================================================

现在使用起来就变得相对简单了：

//=========================================================

int main(){

std::string str("

hello,World,Ni,Hao,A"

);

std::vector<std::string>v_str;

__split(v_str, str, "

,"

);

std::cout <<"

===============split=============="

<<std::endl;

for (auto &

v : v_str){

std::cout <<v <<std::endl;

}

std::string __str = __join(v_str, "

—"

);

std::cout <<"

================join============="

<<std::endl;

std::cout <<__str <<std::endl;

std::string __str2 = boost::algorithm::join_if(v_str, "

—"

, [&

](const std::string&

s){

return boost::algorithm::contains(s, "

l"

);

});

std::cout <<"

===========join if=================="

<<std::endl;

std::cout <<__str2 <<std::endl;

str = "

Hello :::::: World"

;

v_str.clear();

boost::algorithm::split(v_str, str, boost::algorithm::is_any_of("

:"

),boost::algorithm::token_compress_on);

str = ("

123,345,981,3345,98"

);

std::vector<int>v_int;

__split(v_int, str, "

,"

);

std::cout <<"

=========split for int============"

<<std::endl;

for (auto&

v : v_int){

std::cout <<v <<std::endl;

}

std::string str3 = __join(v_int, "

—"

);

std::cout <<"

========join for int============"

<<std::endl;

std::cout <<str3 <<std::endl;

return 0;

}

//=====================================================

关于join_if的扩展就留给大家当是练习吧。

转眼间，我们的编程教室都已经两年了，只是今年好像都一直比较忙，所以更新得不多，但是会坚持下去，谢谢大家的一直支持，新的一年里，大家共勉。

//===================================================

回复D或者d查看目录，回复阿拉伯数字查看相应章节。

原文始发于微信公众号（

C/C++的编程教室

）：第117讲 boost::algorithm::string之分割与合并

|

boost::algorithm::string可以说是很全面的处理字符串的一些算法的集合，上一讲我们说来查找一簇函数，那么这一讲我们说的是替换和删除，为什么替换和删除要一起说呢？因为他们的其实是一样的，删除可以是替换的特殊情况(将其替换为"

"

）。

和查找一簇函数一样，替换和删除函一样拥有多个版本，如下：

//==============================================

replace/erase_first // 替换/删除第一次出现的字符串

replace/erase_last // 替换/删除最后一次出现的字符串

replace/erase_nth
// 替换/删除第n次出现的字符串 ，这个函数和我们说过的MString的有些区别，MString的索引是从开始的，这里是从开始的

replace/erase_all
// 替换/删除所有

replace/erase_head // 替换/删除前面的多少个字节

replace/erese_tail // 替换/删除最后多少个字节

//==============================================

这些函数中前面8个拥有前缀i_版本和后最_copy的版本，前缀i_的版本是不区分大小写的替换或者删除，而后缀_copy的版本是不修改原始字符而返回一个新的你所需要的字符串。而对于后面4个函数来说因为是不管字符问题而是直接修改多少个字节问题所以并没有前缀i_的版本。

下面我们来每个函数简单举个例子给大家演示一下用法，其实相当简单:

//==============================================

std::string str("

Hello World Hello Hello"

);

boost::algorithm::replace_first(str, "

Hello"

, "

NoHello"

);

// 将第一次出现的Hello替换为NoHello

std::cout <<str <<std::endl;

// NoHello World Hello Hello

boost::algorithm::erase_head(str, 2);

// 将前面的两个字节删掉

std::cout <<str <<std::endl;

// Hello World Hello Hello

boost::algorithm::replace_nth(str, "

Hello"

, 1, "

NoHello"

);

// 将第二个Hello替换为NoHello

std::cout <<str <<std::endl;

// Hello World NoHello Hello

boost::algorithm::replace_first(str, "

NoHello"

, "

Hello"

);

// 恢复原状

std::cout <<str <<std::endl;

boost::algorithm::replace_last(str, "

Hello"

, "

NoHello"

);

std::cout <<str <<std::endl;

// Hello World Hello NoHello

std::string str2 = boost::algorithm::replace_last_copy(str, "

NoHello"

, "

Hello"

);

std::cout <<str2 <<std::endl;

// Hello World Hello Hello

std::cout <<str <<std::endl;

// Hello World Hello NoHello

//=================================================

//=============================================

回复D或者d查看目录，回复阿拉伯数字查看相应章节

原文始发于微信公众号（

C/C++的编程教室

）：第116讲 boost::algorithm::string之替换和删除

|

本打算说boost的string_algorithm的，因为这个库是专门针对字符串处理的，而且原本的计划是说完这个之后我们就继续说正则表达式，但是细想了下，正好手头有这么一个库，他不但有boost的string_algorithm的常用操作方法，同时还提供对正则表达式的操作，还可以和标准库的算法无缝结合，所以，论实用性，该库拥有良好的操作界面，但论效率，自然是比不上标准库的string，主要体现在连续赋值的操作上，这个库原本打算使用标准库的分配器来进行内存分配的，但是后来没有采用，只是进行了char*的封装，测试过malloc和new的性能，结果最后的结果竟然是差不多，所以最后也连malloc和realloc也抛弃了，选择使用new来作为内存的分配器，这样对C++的同学来说如果要看源码也是很好理解的。

该库的下载链接如下：

http://yun.baidu.com/share/link?shareid=111953120&

uk=2114708594

同样是在vs2013下面编译的静态库，所以如果你们要使用的话须得在该平台下，当然如果你们想要源码自己编译自己的平台的话，那么我可以给你们源码。

好吧，我们就跑步进入主题吧，现在先来介绍该库的一些特征。

关于该库的界面，大家可以通过MString.h文件查看所有的接口，不过因为该库使用了模板的结合，又添加有大家的特化（特化是为了更好的提高效率），所以看来可能会比较辛苦，当然好处是可以看见源码。

该库最大的特点：

引用计数，内存共享，使用了完美的写时复制技术，在使用过程可以获得更好的性能体验和内存的控制，因为拥有更大的灵活性同时降低了封装性，当然，有得就会有失。

现在我们来看看怎么使用他：

1，关于构造

和std::string一样简单粗暴的构造方式，他还可以使用一个系列进行构造。

//=====================================

mj::MString str((std::istreambuf_iterator<char>(std::cin)),

std::istreambuf_iterator<char>());

std::cout <<str <<std::endl;

//=====================================

该操作将会由键盘输入来构造，遇到Ctrl+Z后停止输入，另一个另类的构建方式：

//=====================================

mj::MString str((std::istream_iterator<char>(std::cin)),

std::istream_iterator<char>());

std::cout <<str <<std::endl;

//=====================================

该构造方式和上面的一样，只是这一次的结果将所有空格都忽略了。

还可以通过std::string 的迭代器来构造：

//=====================================

std::string stdstr("

Hello World"

);

mj::MString str(stdstr.begin(),stdstr.begin()+5);

std::cout <<str <<std::endl;

//=====================================

所以自然也支持他自己的迭代器构造：

//=====================================

mj::MString stdstr("

Hello World"

);

mj::MString str(stdstr.begin(),stdstr.begin()+5);

std::cout <<str <<std::endl;

//=====================================

其他的都是简单粗暴的构造方式，所以这里就不细说了。

另外的复制构造，赋值操作和你们所想的一样，没啥好说，但是值得一提的是这里的赋值和复制是共享一块内存，所以这里的复制和赋值操作的代价是一个时间常量。

//====================================

mj::MString stdstr("

Hello World"

);

mj::MString str(stdstr);

mj::MString str1;

str1 = stdstr;

std::cout <<stdstr.GetAddr() <<std::endl;

std::cout <<str.GetAddr() <<std::endl;

std::cout <<str1.GetAddr() <<std::endl;

std::cout <<str.reference_count() <<std::endl;

//======================================

这里我们可以看到3个对象地址是一样的，同时也看到当前的引用计数为3

下面我们来对任意一个进行修改：

//=====================================

str[0] = 'W';

std::cout <<stdstr.GetAddr() <<std::endl;

std::cout <<str.GetAddr() <<std::endl;

std::cout <<str1.GetAddr() <<std::endl;

std::cout <<str.reference_count() <<std::endl;

//======================================

很明显，str的地址改了，而且当前他的引用计数变成了1，但是当我们换个操作方式：

//=====================================

char ch = str[0];

std::cout <<stdstr.GetAddr() <<std::endl;

std::cout <<str.GetAddr() <<std::endl;

std::cout <<str1.GetAddr() <<std::endl;

std::cout <<str.reference_count() <<std::endl;

//=====================================

这是并没有发生任何变化，这里也就是说，当我们对MString操作[]作为左值时当前的对象会被单独拿出来进行修改，但是当我们只是简单的读取时并没有发生任何变化，这就是完美的写时复制技巧，可以避免我们在操作字符串时不必要的拷贝和意外的修改。

那么接下来看看他的新特性：

//=====================================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test

"

;

std::cout <<str <<std::endl;

//=====================================

是不是很方便的操作呢，因为该库提供了operator+=,operator+,operator<<等等很多方便的操作符，所以使用起来相当的方便，因为这些操作都是泛型操作，所以只要可以使用ostream<<操作的类型都可以使用这些操作来变换成MString。但是有一点需要注意，看到上面我们的写法了吗？

我们使用:str = str + ………..;

你们可能在想，为什么不直接使用 str += …………….;

这里有个优先级问题，在C++里面， 右边的优先级总是高于左边，所以如果使用 str += ………的话，那么是后面的先执行这些操作，但是后面的这些类型不一定都可以有这些操作，所以就不会成功，但是我们使用 str = str + ………………的话，那么先计算的是 str+ X ，这里结果返回的是MString的引用，所以他可以继续一直操作下去。但是如果我们使用<<的话就更方便了，我们不用考虑什么，直接str<<…….就好。

提供了任意类型转换到MString，那么也提供了从MString转换到任意类型的方法：

ToOtherType()，名字难听了些，但直截了当，不过他的转换从开始遇到无法转换就停止，比如：

//===================================

mj::MString str0("

123 456 789"

);

int
num = str0.ToOtherType<int>();

std::cout <<num <<std::endl;

//结果
num = 123

//==================================

这里在遇到空格时发现无法转换为int于是转换结束，结果就是123，这种方法的好处是不修改原始数据，但是下面的操作就会对原始数据进行修改：

//==================================

mj::MString str0("

123 456 789"

);

int num;

str0 >>num;

std::cout <<num <<std::endl;

// 123

str0 >>num;

std::cout <<num <<std::endl;

// 456

str0 >>num;

std::cout <<num <<std::endl;

// 789

std::cout <<str0.empty() <<std::endl;

// 1

//==================================

operator>>操作符将MString当成一个数据源，>>不断地将数据输出来，为了很好的实现这个操作符，这里使用模板元技巧，将std::string和MString两种类型进行了特殊处理。

//==================================

mj::MString str0("

123 456 789"

);

std::string num;

str0 >>num;

std::cout <<num <<std::endl;

// "

123 456 789"

std::cout <<str0.empty() <<std::endl;

// 1

//==================================

如果需要输出的是std::string 或者是MString的话，会一下子将数据全部返回来。

下面来看看修剪功能:

//=================================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test

"

;

mj::MString str1 = str;

std::cout <<str <<1 <<std::endl;

str.trim_right();

// 删除右边的空格

std::cout <<str <<1 <<std::endl;

str.trim_left();

// 删除左边的空格

std::cout <<str <<1 <<std::endl;

str1.trim();

// 该操作等效率上面的两个操作

std::cout <<str1 <<std::endl;

//================================

下面再来看看分割操作，分割操作提供了泛型操作，可以支持带两个模板参数的模板容器，而且需要带有push_back操作的，就标准库而言就有vector,list,deque可以用来当作返回容器，该函数的声明为：

//================================

template<typename T,typename A, template<typename T1, typename A1>class C>

void split(is_any_of any, C<T, A>&

result);

//===============================

is_any_of 需要分割的标志，用法很简单：

//===============================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test

"

;

std::vector<std::string>vv;

str.split("

t"

, vv);

std::cout <<str <<std::endl;

for (auto&

v : vv){

std::cout <<v <<std::endl;

}

//==============================

如同结果显示一样，我们按照给定的空格或者t来将数据分割下来。

还有一个分割方式使用正则表达式来进行分割，使用正则表达式来操作的方法都带有reg_作为前缀，如下：

//===============================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test

"

;

std::vector<std::string>vv;

str.reg_split("

\s+"

, vv);

std::cout <<str <<std::endl;

for (auto&

v : vv){

std::cout <<v <<std::endl;

}

//================================

结果和上面的是一样的，当然使用正则表达式分割方式我们还可以将数据都消除，如下：

//=================================

str.reg_split("

(\s+)|(\d+)"

, vv);

std::cout <<str <<std::endl;

for (auto&

v : vv){

std::cout <<v <<std::endl;

}

//=================================

这次，我们将所有的数字和空格都消除了，剩下的就是字符。

分割操作在平时使用过程中是使用得最为频繁的了。

关于查找功能，如同名字一样，都是以find_为开头，find_first查找第一次出现的位置，find_last查找最后一次出现的位置，find_nth查找第n次出现的位置，这里需要说的是纠结了很久，最后决定让索引从1开始，这些函数都是泛型函数，为的就是更方便的操作，比如：

//==================================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test "

;

size_t pos = str.find_first(123);

// 我们查找的是123.而不是"

123"

if(pos != mj::MString::npos){

std::cout<<pos<<std::endl;

}

else{

std::cout<<123<<"

isn't exist"

<<std::endl;

}

//==================================

该库的查找核心是KMP算法，其实本来大可以使用标准库的serch或者find等等更为高效的算法，虽然说KMP算法也算是很高效的查找方式，但是终究是自己手写的，没有标准库的那些待优化的做得好，但是该库的目的只是为了操作方便而已，但是对于现在的硬件来说，这点性能的累赘应该不会成为问题，只是如果我们选择使用std::serch的话会获得更高的效率，以后有时候这个会更新。

提供有一系列的替换函数簇，一如名字一样，可以很好的理解：

//==================================

mj::MString str;

str = str + "

Hello "

+ 123 + "

World "

<<789 <<"

This "

<<10 <<"

is only a test "

;

str.replace_first("

123"

, 789);

std::cout <<str <<std::endl;

//=================================

还有一个更为强大系列，使用正则表达式来替换：

//=================================

str.reg_replace("

(\s+)|(\d+)"

, "

"

);

std::cout <<str <<std::endl;

//==================================

该方法将数字和空格全部替换掉。

关于替换一簇函数还有一个带_copy后缀的，使用该系列不会修改原始数据，而且返回一个新的MString对象。

append，push_back等等这些泛型函数也就顾名思义了，size和length这些函数都是时间常量复杂度的。

start_with;

以什么开头

end_with ;

以什么结尾

istart_with;

不区分大小写的start_with

iend_with;

不区分大小写的end_with

erase_系列函数和replace_系列对应，也有带有_copy的系列。

all,判断是否全部满足条件，比如：

//==================================

mj::MString str("

Hello"

);

std::cout<<str.all([&

](char c){

return c >80;

}) <<std::endl;

//==================================

结果为false，因为H<80

to_upper;

全部转换为大写。

to_lower;

全部转换为小写。他们同样有_copy的版本。

下面来看看正则表达式的一些操作：

reg_match 检查字符串是否匹配给定的表达式，必须全匹配才得算正确：

//==================================

mj::MString str("

Hello 123"

);

std::cout <<str.reg_match("

\w+"

) <<std::endl;

// false

std::cout <<str.reg_match("

\w+\s+\d+"

) <<std::endl;

// true

//==================================

reg_serch 只要有一个匹配就返回true

//==================================

mj::MString str("

Hello 123"

);

std::cout <<str.reg_serch("

\w+"

) <<std::endl;

// true

std::cout <<str.reg_serch("

\w+\s+\d+"

) <<std::endl;

// true

//==================================

有时候我们不光只是检查是否有匹配项，还需要获取匹配的结果，下面的两个函数就是满足这个功能的：

//=================================

template<class T,class A,template<class T1,class A1>class C>

bool reg_match(const std::string&

reg, C<T, A>&

result);

// 要求全匹配

template<class T,class A,template<class T1,class A1>class C>

bool reg_serch(const std::string&

reg, C<T, A>&

result) // 只返回第一个匹配的信息

template<class T, class A, template<class T1, class A1>class C>

void reg_serch_all(const std::string&

reg, C<T, A>&

result) // 返回所有匹配的信息

//===================================

看下面例子：

//===================================

mj::MString str("

Hello 123 World 789 hah 102 "

);

std::vector<std::string>vv;

str.reg_serch("

\d+"

, vv);

for (auto v : vv){

std::cout <<v <<std::endl;

} // 结果只有 123

str.reg_serch_all("

\d+"

, vv);

for (auto v : vv){

std::cout <<v <<std::endl;

} // 结果只有 123 789 102

//==================================

copy功能，为什么有这个功能呢，因为该库的特点就是内存共享，所以我们使用普通的复制赋值操作是不能完成有时候我们想要的copy的，所以特点提供有copy功能，该功能将数据重新拷贝一份出来，如果不想让他共享的，可以使用markunshare函数标记一下，该对象的内存就不再被共享。

//==================================

mj::MString str("

Hello 123 World 789 hah 102 "

);

mj::MString str1 = str.copy(0, 4);

std::cout <<str1 <<std::endl;

// Hello

mj::MString str2 = str.copy(str.begin(), str.begin() + 5);

std::cout <<str2 <<std::endl;

// Hello

//==================================

reference_count() 查看当前数据被引用的次数。

如同std::string一样，可以有迭代器操作，begin()和end()的操作方式一样，因为他们，所以MString可以和标准库的算法实现完美的结合，例如：

//=================================

mj::MString str("

Hello 123 World 789 hah 102 "

);

auto it = std::find(str.begin(), str.end(), '1');

if (it != str.end()){

std::cout <<*it <<std::endl;

}

else{

std::cout <<"

find fail …. "

<<std::endl;

}

// 输出 1

std::iter_swap(str.begin(), str.begin() + 4);

std::cout <<str <<std::endl;

// oellH …….

//=================================

最后说一下带类型安全检查的格式化功能，我没有提供其他的函数，而是之间简单的重载operator()，但是通常如果使用格式化的时候最好先使用clear，否则会将数据添加在后面，如下：

//=================================

mj::MString str("

Hello"

);

str("

%1 %2 %3 %4"

, 123, "

world"

, 789, "

Haha"

);

std::cout <<str <<std::endl;

str.clear();

str("

%1 %2 %3 %4"

,"

Hello"

, 123, "

world"

, 789);

std::cout <<str <<std::endl;

//=================================

使用起来非常方便，大家可以慢慢探索，如果还有不能满足需求的，可以提出你们的意见。这一讲的内容好像有些多得过分了，不过没关系，大家可以慢慢消化，其实也不多，就像平时使用一样使用就好。

//===============================

回复D或者d查看目录，回复数字查看相应的章节

原文始发于微信公众号（

C/C++的编程教室

）：第114讲 MString

|

这些天都比较忙，所以没时间更新新内容，不过说实在的，对于C++的内容我们已经没多少可以拿出来说的了，当然对于基础知识，我们早就说完了，有些朋友，没有看过一讲，就问，有没有不要基础的？我想可能大概是我们的章节名都取得太随意太简单太直观化了些，所以有些朋友认为我们的内容说得很基础，但是我想真正看过里面内容的朋友肯定不会这么认为，我们里面引入的都是些很有技巧性的技术，好了，废话不多说，我们今天继续来说新的东西——关联容器。

关于容器，我们说了序列容器，至于大家吸收了多少这就是看大家的了，如果还有不明白的，可以回去多看几遍，其实，STL里面的东西不难如果我们只想去使用的话，尤其是在我们知道他们的原型之后，用起来更是轻松加愉快，当然，如果我们真心要研究STL的算法的话，那可能就有点难度了，所以，我只给大家提供原型和一些简单的实现，想要深入研究STL里面的东西，等我们打算去研究算法的时候再来研究吧。我们现在要做的就是拿来使用。

map在关联容器里的重要性如同vector在序列容器的重要性一样，所以，在说关联容器的时候我们肯定先来说说map。

map第一次接触他的时候我就想怎么就出了个地图了呢？后来又听说他叫字典，我就纳闷，怎么地图就变成了字典了呢？这个笑话有些冷，不过当初真是这样的。好了，我们今天先来看看map吧。
——————————–
template<typename Key,typename T,typename Cmp=less<Key>,

typename A=allocator<pair<const Key,T
>>>
class map{
public:

//还是老规矩，每个容器在一开始都要有一系列的类型定义

typedef Key key_value;

typedef T mapped_type;

typedef pair<const Key,T>value_type;

//这点和我们以前所说的序列容器有所不同，这也就是他的重点。

typedef Cmp key_compare;

typedef A allocator_type;

typedef typename A::reference reference;

typedef typename A::const_reference const_reference;

typedef implementation_defined1 iterator;

typedef implementation_defined2 const_iterator;

typedef typename A::size_type size_type;

typedef typename A::difference_type difference_type;

typedef std::reverse_iterator<iterator>reverse_iterator;

typedef std::reverse_iterator<const_iterator>const_reverse_iterator;

//

//

};

———————————

好吧，今天算是个开始，我们就先熟悉这一些的typedef，这些东西都没啥难的，不过我们要注意一点，那就是上面我们提到的value_type，这里他既不是T也不是Key，而是一个pair<Key,T>，在pair里面，Key是键，T是值，在pair里面，有两个成员，一个first，一个second，我们来看看pair是啥东西就知道了，还记得我们说的快速排序吗？当时我把微软的源码拿出来，里面就用到了pair。
————————–
template<typename Key,Typename T>
class pair{
public:

Key first;

T second;

pair():first(Key()),second(T()){ }

pair(const Key&

x,const T&

y):first(x),second(y){ }

template<typename U,typename V>

pair(const pair<U,V>&

p):first(p.first),second(p.second){ }
};

—————————

Ok，今天先到这里吧。

==========================

回复D直接查看目录

原文始发于微信公众号（

C/C++的编程教室

）：第七十五讲 细说map（1）

|