从 STL 出现到现在已经这么多年了，泛型算法是它的重要组成，也是其中最“看起来很美”的东西之一。然而在真实的程序设计中，它往往成为程序员的心头一痛，因为一旦要用 for_each ，accumulate 之类的算法做一些稍微复杂一点的事情，你就会发现自己一个头变成两个大。
从 STL 出现到现在已经这么多年了，泛型算法是它的重要组成，也是其中最“看起来很美”的东西之一。然而在真实的程序设计中，它往往成为程序员的心头一痛，因为一旦要用 for_each ，accumulate 之类的算法做一些稍微复杂一点的事情，你就会发现自己一个头变成两个大。即便是有了 boost::bind 和 boost.lambda 的帮助，事情也仍然是扑朔迷离，求助于 comp.lang.c++ 虽然有用，但是又何尝不是一种无奈。好了，现在我开始收集一些来自 comp.lang.c++(.moderated) 的解答，希望日后对自己和他人有用。
=================================================================================
预备问题（算是第0个问题吧）：如何对一个 STL 容器内的所有元素做某件事情？
这取决于你要做什么，以及容器是什么。如果是 vector, list 这样的容器，而你要把它们全部 cout 出来，当前的标准 STL 解法是这样的：
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
#include <string>
int main()
{
std::vector<std::string> vect;
vect.push_back("Hello");
vect.push_back(", ");
vect.push_back("world!");
std::copy( vect.begin(), vect.end(),
std::ostream_iterator<std::string>(std::cout) );
}
基本上，这算是一个“过得去”的方案，但是有点问题：
1. 对于不熟悉这个固定用法的人，cout 所有元素所首要考虑算法是 for_each，而不是 copy ，事实上，for_each 也是最符合我们惯常逻辑的算法，因为在不使用 STL 算法的时候，我们使用 for 循环来干这件事。
2. 可读性不太良好，ostream_iterator 的使用有点 tricky ，而且也不能用于做其他的事情。
我想熟悉 boost 的人已经知道我下面要说什么了，因为用 boost.lambda 做这件事情的确非常漂亮：
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
int main()
{
std::vector<std::string> vect;
vect.push_back("Hello");
vect.push_back(", ");
vect.push_back("world!");
std::for_each( vect.begin(), vect.end(), std::cout << _1 );
}
这和前面的程序一样，输出我们熟悉的 Hello, world! 。直观、优雅而且容易修改，例如，如果你不是想要输出它们的值，而是想要输出它们的长度，只需要做很少的修改：
std::for_each( vect.begin(), vect.end(), std::cout << bind(&std::string::length, _1) << "\n" );
输出
5
2
6
bind 的作用是把 lambda 表达式绑定到一个函数或者一个数据成员，在这里的意思，就是对于每一个 string ，都调用其 length() 方法。_1 同样也可以成为赋值的对象，例如，先执行
std::for_each( vect[0].begin(), vect[0].end(), _1 = bind(&toupper, _1) );
然后再把这些 string 输出，你会得到
HELLO, world!
因为那一句对 "Hello" 中的每一个字母调用 toupper ，并把结果写回。
=================================================================================
第一个问题：如何对一个 map 中所有的 key 或者 value 做某件事情？
当然，这还是取决于你要做的是什么。手写 for 循环当然是万能的，但是现在有了那么多的泛型算法，我们可以考虑其他的方案了（这也是众多 C++ Gurus 推荐的思维方式）如果是把所有的 value 全部 cout 出来，用 boost.lambda 配合 for_each 还是比较优雅的（虽然没有像 vector 和 list 那样的优雅）：
#include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
int main()
{
std::map<int, std::string> strs;
strs[0] = "Hello";
strs[1] = ", ";
strs[2] = "world";
strs[3] = "!";
std::for_each( strs.begin(), strs.end(),
std::cout << bind(&std::map<int, std::string>::value_type::second, _1) );
}
这样的输出如我们所料，就是 Hello, world! 。
如果想要把 key 也输出，道理是一样的，只需要这样：
std::for_each( strs.begin(), strs.end(),
std::cout << bind(&std::map<int, std::string>::value_type::second, _1) << '\t'
<< bind(&std::map<int, std::string>::value_type::first, _1) << '\n'
);
其结果是：
Hello 0
, 1
world 2
! 3
因此，对于一个 map 中的 value 的操作往往可以依法炮制，如果我们想要在其中寻找 value 为 “world" 的那一个元素，并且输出它的 key ，只需要一句话：
std::cout <<
std::find_if( strs.begin(), strs.end(),
bind(&std::map<int, std::string>::value_type::second, _1) == "world" )->first;
STL 算法 find_if 接受的第三个参数是一个 prediate ，而生成这种临时的 functor 正是 lambda 的拿手好戏。上面的这句话也可以用 boost::bind 来做，只需要更改 include 和 using namespace ，代码本身无需更改。而如果你不借助于它们，你只有手写循环或者自己写一个 predicate 。
当情况变得复杂一些的时候，lambda 的用法也变得更加有趣了：
#include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
class Person
{
public:
Person(){}
Person(const std::string& name) : name_(name){}
std::string Name()
{ return name_; }
private:
std::string name_;
};
int main()
{
std::map<int, Person> persons;
persons[123] = Person("Amy");
persons[234] = Person("Ralph");
persons[345] = Person("Simon");
persons[456] = Person("Maggie");
std::for_each( persons.begin(), persons.end(),
std::cout << bind(&std::map<int, Person>::value_type::first, _1) << '\t'
<< bind(&Person::Name,
bind(&std::map<int, Person>::value_type::second, _1)) << '\n'
);
std::cout << "Ralph's Id is: " <<
std::find_if( persons.begin(), persons.end(),
bind(&Person::Name,
bind(&std::map<int, Person>::value_type::second, _1)) == "Ralph" )->first;
}
这里 map 的 value 元素不再是一个单纯的 string，我们要输出的是这个 value 的 Name() ，幸好 lambda 的绑定可以级联，所以我们仍然可以用 STL 算法在一个表达式之内搞定这些任务：for_each 输出 key 和 value 的 Name()，而 find_if 找到 value 的 Name() 为 "Ralph" 的那一个元素，输出是这样的：
123 Amy
234 Ralph
345 Simon
456 Maggie
Ralph's Id is: 234
如果你想要把一个容器内的所有元素累加起来，应该怎么办？
如果你想要把一个容器内的所有元素累加起来，应该怎么办？
STL 的 accumulate 可以让我们不必自己写循环：
#include <iostream>
#include <functional>
#include <numeric>
#include <vector>
#include <string>
int main()
{
std::vector<int> vect;
vect.push_back(1);
vect.push_back(2);
vect.push_back(3);
vect.push_back(4);
std::cout << "Accumulate: " <<
std::accumulate( vect.begin(), vect.end(), 0, std::plus<int>());
}
输出：
Accumulate: 10
其中的 std::plus<int>() 可以省略，因为这将是3个参数的 accumulate 的默认行为。 注意 accumulate 算法是定义在 numeric 里面而不是 algorithm 里面的。
由于 accumulate 和 plus 都是泛型的，所以如果你要累加的不是 int 而是字符串，对程序的修改也并不大：
#include <iostream>
#include <functional>
#include <numeric>
#include <vector>
#include <string>
int main()
{
std::vector<std::string> vect;
vect.push_back("1");
vect.push_back("2");
vect.push_back("3");
vect.push_back("4");
std::cout << "Accumulate: " <<
std::accumulate( vect.begin(), vect.end(), std::string(""));
}
输出：
Accumulate: 1234
不过，如果使用 boost.lambda ，这个问题会有一些很好看又容易理解的解法：
#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
//#include <boost/bind.hpp>
using namespace boost::lambda;
//using namespace boost;
int main()
{
std::vector<std::string> vect;
vect.push_back("1");
vect.push_back("2");
vect.push_back("3");
vect.push_back("4");
std::string result;
std::for_each( vect.begin(), vect.end(), result += _1);
std::cout << result;
}
输出：
1234
这里要借用变量 result ，在这个程序中显得多了几行，但是我们调用 accumulate 的目的也往往是把结果放到一个变量中，这样的话，使用 boost.lambda 反而会漂亮一些。
在上面的程序中，另一个丑陋的地方就是 vector 的初始化，为了把 1, 2, 3, 4 放进 vect 里面，我们居然要调用 push_back 4次！不过，使用 boost.lambda 就好得多了。
std::vector<int> vect(10);
int i = 0;
std::for_each( vect.begin(), vect.end(), _1 = ++var(i) );
这里有两个地方值得注意：
1. 现在必须在 vect 的声明中指出其大小，否则 for_each 对一个空容器可是什么也不会做
2. 必须使用 ++var(i) ，而不是 ++i 。var 在这里的作用是强迫 lazy evaluation ，也就是让变量在被用到的时候在求值，如果用 ++i ，你会得到一个装有10个1的 vect ，而不是装有1-10。
=================================================================================
许多问题遇到 map 都会变得复杂起来，如果想要把一个 map 中所有的 key 或者 value 累加起来，该怎么办呢？这个时候已经不能直接使用 accumulate 了，用 boost.bind 可以办到，做法是这样的：
#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>
#include <boost/bind.hpp>
using namespace boost;
int main()
{
std::map<int, std::string> persons;
persons[123] = "Amy";
persons[234] = "Ralph";
persons[345] = "Simon";
persons[456] = "Maggie";
std::cout << std::accumulate( persons.begin(), persons.end(), 0,
bind(std::plus<int>(), _1, bind(&std::map<int, std::string>::value_type::first, _2)) )
<< std::endl;
std::cout << std::accumulate( persons.begin(), persons.end(), std::string(),
bind(std::plus<std::string>(), _1, bind(&std::map<int, std::string>::value_type::second, _2)) )
<< std::endl;
}
输出：
1158
AmyRalphSimonMaggie
办是办到了，但是平心而论，的确算不上是漂亮。连续的 bind 并不比自己写的循环更让人头晕。boost.lambda 也要用到 bind ，然而可以清晰许多：
#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
int main()
{
std::map<int, std::string> persons;
persons[123] = "Amy";
persons[234] = "Ralph";
persons[345] = "Simon";
persons[456] = "Maggie";
int iresult = 0;
std::string sresult;
std::for_each( persons.begin(), persons.end(),
iresult += bind(&std::map<int, std::string>::value_type::first, _1)
);
std::for_each( persons.begin(), persons.end(),
sresult += bind(&std::map<int, std::string>::value_type::second, _1)
);
std::cout << iresult << std::endl;
std::cout << sresult << std::endl;
}
输出和上面的一样：
1158
AmyRalphSimonMaggie
有了它的帮助，即便间接层次再增加一层，也不会有太多困难：假如你的 map 并不直接存储 string ，而是存储 Person 对象，而它们的名字要通过 Name() 方法来取得，代码只需要稍微的修改：
#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
class Person
{
public:
Person(){}
Person(const std::string& name) : name_(name){}
std::string& Name()
{ return name_; }
private:
std::string name_;
};
int main()
{
std::map<int, Person> persons;
persons[123] = Person("Amy");
persons[234] = Person("Ralph");
persons[345] = Person("Simon");
persons[456] = Person("Maggie");
std::string result;
std::for_each( persons.begin(), persons.end(),
result += bind(&Person::Name, bind(&std::map<int, Person>::value_type::second, _1))
);
std::cout << result;
}
输出：
AmyRalphSimonMaggie
上次提到过为容器生成数据的问题，我给出的用 boost.lambda 的方法是
上次提到过为容器生成数据的问题，我给出的用 boost.lambda 的方法是：
std::vector<int> vect(10);
int i = 0;
std::for_each( vect.begin(), vect.end(), _1 = ++var(i) );
不错，这样可以生成连续的数字，也还算比较简洁，因为代码量不会随着容器的大小而变化，不过，如果要在容器内填入随机数呢？其实比上面更简单，因为 STL 的 generate 算法就是设计来做这个的：
std::vector<int> vect(10);
std::generate(vect.begin(), vect.end(), rand);
rand 是我们熟悉的标准 C 库函数，这样我们可以生成任意数量的随机数了，不过还是有点不好的地方：每次生成的序列都是一样的，因为 rand 生成的是伪随机数。这个容易解决，我们必须先 seed 一下：
std::vector<int> vect(10);
srand(time(NULL));
std::generate(vect.begin(), vect.end(), rand);
好了，我们终于还是用了三行（其实是两行，声明 vector 总是必需的吧！），但是好歹是有了一个可用的方案。回头看看，前面的连续整数问题也可以用 generate 来做，方法不言而喻：
std::vector<int> vect(10);
int i = 0;
std::generate(vect.begin(), vect.end(), ++var(i));
好处是 generate 本身更能说明这句话的用途，当然这个可能因人而异。
我知道有人一定在问：一定要两行么？一定要有一个初始变量么？答案是可以没有，但是要用到另外的算法，再加上 boost.lambda 的协助。看看下面：
std::vector<int> 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 充当了这个角色，它相当于
而 partial_sum 呢？它把一个序列的 partial sum 送到结果序列中去，例如如果输入一个数组 v[10] ，而输出是 r[10] ，那么它的计算就是
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[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 算法 reverse 可以派上用场，不过也不要忘了 STL 还有 reverse_iterator 这回事，用它就无需另外调用 reverse 了：
std::partial_sum(vect.rbegin(), vect.rend(), vect.rbegin(), _2 = 2*_1 + 1);
得到
511 255 127 63 31 15 7 3 1 0
最后还要提醒大家不要忘了一个很有用的 STL 算法： random_shuffle 。它可以把 Random access container 里面的值打乱，配合上面的数列生成，在很多场合是进行测试 （例如测试排序算法） 的好工具。在我的机器上，下面两行
std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);
std::random_shuffle(vect.begin(), vect.end());
得到打乱以后的数列：
255 1 511 3 0 31 127 7 15 63
=================================================================================
有了强大的生成机制作基础，下面的实验也更加容易了。STL 的 count_if 和 find_if 都接受一个 predicate 作为比较的依据，而这个 predicate 往往非常简单，以至于为它专门写一个 functor 简直不可接受。在第一篇里面已经展示了用 boost.lambda 生成临时的无名 functor 的能力，这里再多说一点。
下面先生成 2^n - 1 的数组，然后找出其中第一个大于100的数
std::vector<int> vect(10);
std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);
std::cout << *std::find_if(vect.begin(), vect.end(), _1 > 100);
输出为 127 ，如我们所料。同样道理，如果是 count_if ，则会得到大于100的数的个数
std::cout << std::count_if(vect.begin(), vect.end(), _1 > 100);
输出是 3 。注意细节：find_if 返回一个 iterator ，所以在它之前有 * 解引用，而 count_if 直接返回一个数字，无需解引用。
与之类似的还有 STL 的 partition 算法，它根据传入的 predicate 对一个序列进行划分，predicate 得到 true 的将放在前面，其余的放在后面，返回的是那些“ 放在 后面”的元素中的第一个，换言之就是分界点。下面的代码
std::vector<int> 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)) 。
顺便说一下，上面的几件简单的事情，用标准的 STL 算法都可以办到，只不过实在是……面目可憎：
std::cout << *std::partition(vect.begin(), vect.end(),
std::bind2nd(std::greater<int>(), 100)) << std::endl;
这句代码做的事情和前面的 partition 一模一样，但是孰优孰劣，大家自有公断。
总有一些时候，我们不能够借助于“生成式”的初始化方法来给容器赋值，例如我们已经有了一个数组，要把它作为初值赋给一个容器，常规的做法已经深入人心了
总有一些时候，我们不能够借助于“生成式”的初始化方法来给容器赋值，例如我们已经有了一个数组，要把它作为初值赋给一个容器，常规的做法已经深入人心了：
int init[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
std::vector<int> vect(init, init + sizeof(init)/sizeof(int));
通过两个 sizeof 来得到数组的大小在 C 语言里面是很常见的，然而在 C++ 里面，这即便不能称为丑陋，也绝对称不上是好。首先其可读性不好，其次它要进行一次除法来得到一个本来在编译期间就知道的数字，最后，它并不是总能用的！例如下面的例子：
std::string strs[] = { "Amy", "Ralph", "Simon", "Maggie" };
现在，你打算用 "sizeof " 什么来除以 "sizeof" 什么？
其实，经过了这么多 C++ GP 的磨练，我们很容易就会想到一个在编译期间得到静态数组大小的办法，模板偏特化是我们常用的武器，在这里非常好用：
template <class T>
struct ArraySize
{
static const unsigned int value = 0;
};
template <class T, int S>
struct ArraySize<T[S]>
{
static const unsigned int value = S;
};
就这么简单！虽然它只对付一维数组，但是扩展它是很容易的。不过，模板参数只能为类型，而我们需要传入的是一个变量。好在在计算机科学里面，加一层抽象是可以解决任何问题的，我们只要加一个模板函数，C++ 会自动帮我们做类型推导：
template <class T>
unsigned int array_size(const T&)
{
return ArraySize<T>::value;
}
现在我们可以轻而易举的搞定那些数组了：
int ints[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
std::vector<int> vint(ints, ints + array_size(ints));
std::string strs[] = { "Amy", "Ralph", "Simon", "Maggie" };
std::vector<std::string> vstr(strs, strs + array_size(strs));
std::for_each(vint.begin(), vint.end(), std::cout << _1 << " ");
std::cout << std::endl;
std::for_each(vstr.begin(), vstr.end(), std::cout << _1 << " ");
输出：
2 3 5 7 11 13 17 19 23
Amy Ralph Simon Maggie
顺便说一下，在 boost.type_traits 里面有一个类似于 ArraySize 的工具，叫做 extent ，它更加强大，可以对付多维数组，不过是否值得为了这个而把 boost.type_traits 包含到工程里面去就看读者自己抉择了。
=================================================================================
容器的初始化是如此的常见，以至于 boost 提供了一个 assign 库来简化这些操作。boost.assign 大量利用了重载的逗号和括号来简化赋值操作，提供了甚至比用数组更加简洁的语法：
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <boost/assign/std/vector.hpp>
#include <boost/assign/std/list.hpp>
using namespace boost::assign;
int main()
{
std::vector<int> vint;
vint += 2,3,5,7,11,13,17,19,23;
std::vector<std::string> vstr;
vstr += "Amy","Ralph","Simon","Maggie";
std::list<std::string> 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 <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <boost/assign/list_inserter.hpp>
#include <boost/assign/list_of.hpp>
using namespace std;
using namespace boost::assign;
using namespace boost::lambda;
int main()
{
map<string,int> 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<int,string> persons = map_list_of
(2,"Amy")(3,"Ralph")
(5,"Simon")(7,"Maggie");
for_each( months.begin(), months.end(),
cout << bind(&map<string,int>::value_type::second, _1) << "\t"
<< bind(&map<string,int>::value_type::first, _1) << "\n"
);
cout << endl;
for_each( persons.begin(), persons.end(),
cout << bind(&map<int,string>::value_type::first, _1) << "\t"
<< bind(&map<int,string>::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