C++博客-wounkin-文章分类-cpp

Websites

Wounkin — Wed, 06 Jun 2007 05:43:00 GMT

http://www.gotapi.com/
语言：英语
简介：HTML,CSS,XPATH,XSL,JAVASCRIPT等API的查询网站。
http://www.w3schools.com/
语言：英语
简介：W3C制定的标准诸如XML,HTML,XSL等等的在线学习教程。
http://www.xml.org.cn/
语言：中文
简介：可以说是XML的中国官方网吧。W3C标准的翻译组织与XML系列技术交流社区.
http://www.connectionstrings.com/
语言：英语
简介：这里几乎收集了所有的数据库连接字符(connectionstring)了。
http://www.itpub.net/
语言：中文
简介：我个人认为是国内最专业的综合性行业性技术类社区.
http://www.netvtm.com/
语言：中文
简介：内容多翻译于w3schools.com，少有原创。不过还是应该鼓励精品翻译。
http://www.regexlib.com
语言：英语
简介：正则表达式库。搜索正则表达式用。
http://www.rexv.org/
语言：英语
简介：用Ajax开发的在线正则表达式验证器.
http://www.koders.com/
语言：英语
简介：代码搜索引擎，可以搜索几十种语言的代码。
http://www.123aspx.com/Rotor/
语言：英语
简介：.Net Frameworks的源代码。
http://dotnet.aspx.cc/
语言：中文
简介：孟宪会的资料站，虽资料大多比较简单，却解决了开发中的大部分问题？！
http://www.dofactory.com/Patterns/Patterns.aspx
语言：英语
简介：23种设计模式的实现参考。特点是UML+精练的示例代码+简洁的解说风格。
http://www.open-open.com/
语言：中文
简介：Java开源大全,如果你用.NET，照着它的名字前加N找找应该都有吧？！：）
http://www.riacn.com/
语言：中文
简介：我认为是国内少有的RIA专业技术站于交流社区.
http://www.cnpaf.net/
语言：中文
简介：中国协议分析网，很全面的协议资料网。
http://www.pinvoke.net/
语言：英语
简介：通过.net调用win32等非受控API的资料大全。
http://bbs.51js.com/
语言：中文
简介：无忧脚本,专业的脚本技术社区。
http://www.c-sharpcorner.com/
语言：英语
简介：C# Corner,学习c#的好地方.
http://blog.csdn.net/group/experts/
语言：中文
简介：CSDN专家群,汇集CSDN专家的电子报.
http://www.codeproject.com/
语言：英语
简介：有很多可学习的示例代码，特点是丰富，深入浅出．
http://www.gotdotnet.com/
语言：英语
简介：微软开发维护的关于.net framework交流社区.
http://www.sourceforge.net/
语言：英语
简介：全球最大的开源软体站点
http://www.asp.net/QuickStart/
语言：英语
简介：Microsoft .NET Framework SDK QuickStart Tutorials
http://www.matrix.org.cn/
语言：中文
简介：与 Java 共舞,Java优秀的专业社区,文章质量很高.做.Net的朋友也可以从其借鉴很多知识.
http://www.codeplex.com/
语言：英文
简介：微软的开放源代码网站
http://www.google.com/codesearch
语言：英文
简介：Google的源代码搜索引擎

Wounkin 2007-06-06 13:43 发表评论

generate,partial_sum,for_each

Wounkin — Fri, 01 Jun 2007 01:49:00 GMT

看看下面：

std::vector vect(10);
std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = _1 + 1);

如果你现在把 vect 输出，你会得到：

0 1 2 3 4 5 6 7 8 9

乍看起来不太好理解，我来慢慢解释。
partial_sum 的第4个参数是一个双参数的 functor ，在这里，lambda 表达式 _2 = _1 + 1 充当了这个角色，它相当于

f(x, y) { y = x + 1; }

而 partial_sum 呢？它把一个序列的 partial sum 送到结果序列中去，例如如果输入一个数组 v[10] ，而输出是 r[10] ，那么它的计算就是

r[0] = v[0]
r[1] = f( r[0], r[1] )
r[2] = f( r[1], r[2] )
......
r[9] = f( r[8], r[9] )

而当我们把 partial_sum 作用于 vect 本身，结果就成了

vect[0] = vect[0]                            // vect[0] = 0
vect[1] = (vect[1] = vect[0] + 1)   // vect[1] = 1
vect[2] = (vect[2] = vect[1] + 1)   // vect[2] = 2
......
vect[9] = (vect[9] = vect[8] + 1)   // vect[9] = 9

你一定发现其中的问题所在了：首先，我们必须依赖于编译器把 vect[0] 初始化为0，其次，vect[0] = vect[0] 是不可回避的。以我当前所想到的，也只能这样了。

推广一下，如果把 _2 = _1 + 1 中的常数 1 换成另外的数字，我们就可以用一句话得到从 0 开始的等差数列，例如

std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = _1 + 3);

得到的是

0 3 6 9 12 15 18 21 24 27

如果再发挥一点想象力，你就可以构造出更复杂的 lambda 表达式，从而得到更复杂的数组（也许这里叫数列更好吧），例如

std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2 * _1 + 1);

得到的是 2 的 n 次方 - 1 数列

0 1 3 7 15 31 63 127 255 511

在 STL 算法中，adjacent_difference 和 partial_sum 是逆运算，因此，上面的事情也可以用 adjacent_difference 来做，只不过要把 lambda 表达式中的参数位置换一下，例如要得到 0, 3, 6... 的等差数列，只需要

std::adjacent_difference(vect.begin(), vect.end(), vect.begin(), _1 = _2 + 3);

而 2 的 n 次方 - 1 数列也是同样道理

std::adjacent_difference(vect.begin(), vect.end(), vect.begin(), _1 = 2*_2 + 1);

与之类似的还有 STL 的 partition 算法，它根据传入的 predicate 对一个序列进行划分，predicate 得到 true 的将放在前面，其余的放在后面，返回的是那些“ 放在后面”的元素中的第一个，换言之就是分界点。下面的代码

std::vector vect(10);
std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);

std::cout << *std::partition(vect.begin(), vect.end(), _1 > 100) << std::endl;

std::for_each(vect.begin(), vect.end(), std::cout << _1 << " ");

输出为

7
511 255 127 7 15 31 63 3 1 0

如果仔细观察，还可以发现上面的输出有点问题：数列中原有的顺序（0, 1, 3, 7...）不复存在，这是因为 partition 并不是一个稳定排序的算法，它不保证排序结果保有原来的顺序。如果需要稳定排序，可以使用 stable_partition 。只需要更改排序的那一句代码为

std::cout << *std::stable_partition(vect.begin(), vect.end(), _1 > 100) << std::endl;

结果是

0
127 255 511 0 1 3 7 15 31 63

当然，如果你还记得大学里的算法理论，就知道它们在效率上是有点区别的，partition 的复杂度保证为 O(n) ，具体地说是保证不超过 n/2 次交换；而 stable_partition 在最好情况下为 O(n) ，最差情况则达到 O(n*log(n)) 。

容器的初始化是如此的常见，以至于 boost 提供了一个 assign 库来简化这些操作。boost.assign 大量利用了重载的逗号和括号来简化赋值操作，提供了甚至比用数组更加简洁的语法：

#include
#include
#include
#include

#include
#include

using namespace boost::assign;

int main()
{
std::vector vint;
vint += 2,3,5,7,11,13,17,19,23;

std::vector vstr;
vstr += "Amy","Ralph","Simon","Maggie";

std::list lstr;
lstr += "Amy","Ralph","Simon","Maggie";

std::for_each(vint.begin(), vint.end(), std::cout << _1 << " ");
std::cout << std::endl;
std::for_each(vstr.begin(), vstr.end(), std::cout << _1 << " ");
std::cout << std::endl;
std::for_each(lstr.begin(), lstr.end(), std::cout << _1 << " ");
}

运行这个程序，输出与前面的大致相同，但是我们注意到初始化更加简洁了，而且也不需要额外的空间来存储数组，对于各种类型，都能够以统一的方式来初始化，真是妙不可言。有趣的是 assign 的作者在文档中还特意引用了 Bjarne Stroustrup 的话作为引子：

There appear to be few practical uses of operator,().
Bjarne Stroustrup, The Design and Evolution of C++

这也许就是 C++ 最大的魅力之一：你无法预料它可以办到些什么。

下面关于 map 的例子也使用 boost.assign ，可以看到重载的括号给我们带来了多少方便。

#include
#include
#include
#include

#include
#include

#include
#include

using namespace std;
using namespace boost::assign;
using namespace boost::lambda;

int main()
{
map months;

insert( months )
    ( "january",   31 )( "february", 28 )
    ( "march",     31 )( "april",    30 )
    ( "may",       31 )( "june",     30 )
    ( "july",      31 )( "august",   31 )
    ( "september", 30 )( "october", 31 )
    ( "november", 30 )( "december", 31 );

map persons = map_list_of
    (2,"Amy")(3,"Ralph")
    (5,"Simon")(7,"Maggie");

for_each( months.begin(), months.end(),
    cout << bind(&map::value_type::second, _1) << "\t"
         << bind(&map::value_type::first, _1) << "\n"
);
cout << endl;
for_each( persons.begin(), persons.end(),
    cout << bind(&map::value_type::first, _1) << "\t"
         << bind(&map::value_type::second, _1) << "\n"
);
}

输出：

30      april
31      august
31      december
28      february
31      january
31      july
30      june
31      march
31      may
30      november
31      october
30      september

2       Amy
3       Ralph
5       Simon
7       Maggie

Wounkin 2007-06-01 09:49 发表评论

effect STL条款45

Wounkin — Fri, 01 Jun 2007 01:30:00 GMT

条款45：注意count、find、binary_search、lower_bound、upper_bound和equal_range的区别

对无序区间的查找，我们当然是find，只有当需要统计拷贝的个数，count才有意义。如果对有序区间binary_search告诉你是否有。如果要知道位置，equal_range是一个好的选择。对有序需要的统计当然distance配合equal_range当然要比count的效率高。

1. 期望值是否存在？

(1) 无序区间：find

(2) 有序区间：binary_search

(3) set或者map：count

(4) multiset或者multimap：find

2. 期望值是否存在？如果有，第一个等于这个值的对象在哪里？

(1) 无序区间：find

(2) 有序区间：equal_range

(3) set或者map：count

(4) multiset或者multimap：find或者lower_bound

3. 第一个不在期望值之前的对象在哪里？

(1) 无序区间：find_if

(2) 有序区间：lower_bound

(3) set或者map：lower_bound

(4) multiset或者multimap：lower_bound

4. 第一个在期望值之后的对象在哪里？

(1) 无序区间：find_if

(2) 有序区间：upper_bound

(3) set或者map：upper_bound

(4) multiset或者multimap：upper_bound

5. 有多少对象等于期望值？

(1) 无序区间：count

(2) 有序区间：equal_range,然后distance

(3) set或者map：count

(4) multiset或者multimap：count

6. 等于期望值的所有对象在哪里？

(1) 无序区间：find（迭代）

(2) 有序区间：equal_range

(3) set或者map：equal_range

(4) multiset或者multimap：equal_range

当然，序列容器要用泛型算法，而关联容器用成员函数。

Wounkin 2007-06-01 09:30 发表评论