本来打算写24点的程序，以体现C++对算法表达的清晰性。但在此之前，得先解决一个N个数中取两个数的组合问题，也即C(N,2)，于是想到干脆连排列也一块搞定，而且在讨论全排列的时候，还牵扯到一个有趣的代码问题，因此，就这样专用一文来论排列与组合，内容还相当翔实。但是写完全排列的时候，发现文章已经很长了，只好打住，留待下期再论组合与部分排列。
先来看一段有名代码，稍作了改动，它出自于国外的算法书中，在国内的算法书中到处可以看到它的身影，代码本身确实非常巧妙，但其实，存在很大的问题。
template<typename T>
void Perm(T* pT, int n, int m)
{
if (n == m)
{
for (int i=0; i<m; i++)
cout << pT[i] << " ";
cout << endl;
return;
}
else
{
for (int i=m; i<n; i++)
{
swap(pT[m], pT[i]);
Perm(pT, n, m+1);
swap(pT[m], pT[i]);
}
}
} 循环中出现了递归，有点费解，好比多模板偏特化中又出现了多继承还夹杂着虚函数，但在这里，还是很好理解的，代码按乘法原理来构造，这也是排列算法的由来。计算N个数的全排列，就是针对内中的任一个数实行一次N-1个数的全排列，即N！= N * （N-1）！。循环就是为了让数组中的每个元素都参与到排列中来。首先取出第0个数，对行实行了（N-1）！。然后取出第1个数，其实就是将第1个数放到第0位中，第0个数放到第1个数中，通过Swap函数，实行一次（N-1）！，之后，第1、0个再各就各位，返回原位。计算（N-1）！的时候，也按照N！那样，对N-1个数的任一个数实行（N-2）！。完美的递归出现了，既然有递归，就有结束递归的代码，递归结束在0！，也即是m==n时，表示已经完成了一个排列。由于是循环中出现递归，递归中又出现了循环，因此就算递归完成了，代码还要继续递归，递归到递归中的循环都结束了。当年，我读懂了这段代码之后，马上对递归的理解有了更深刻的认识。
但是，这段代码中存在着一个非常丑陋的缺陷，其输出夹杂在操作之中，假如每一个排列的结果不是要显示在控制台上，而是要写入文本，或者是显示在窗口上，那么就必须修改这个完美递归的排列函数，这无疑很不完美。当然解决之法也不是没有，使用函数对象，C中就只能用回调函数，将其作为参数传入permutate中，每一次递归完成，就祭出函数对象输出排列的结果。Windows API中的很多枚举函数，例如EnumFont，EnumWindows都用了这法子。但我对这个法子很不感冒，它太不可控了；其次，还有另外一个问题，就是Swap中，假如对象很大，每一次交换则将耗费多少CPU资源，而permutate中，基本上是都是在Swap来Swap去；最后也是最大问题，这种方法只可用于全排列，对于部分排列，比如，求P(5,2)，它完全无能为力，因此，必须另寻出路。
……
上面省略了思考的过程，请恕我直接给出解决方案，其实很简单。
先从最简单的排列对象开始考虑，即从0到N的排列数，只要搞定了它的排列方式，就可以搞定所有对象的排列了，WHY？因为0到N可作为数组的索引，可能对这个答案有点迷糊，不要紧，继续看下去。考察我们伟大的大脑是如何做排列的，请动笔，写下4！的全部排列，看能否从中得到什么启发。
0123， 0132， 0213， 0231， 0312， 0321， 1023， 1032， …… ，3201，3210。终于写完了0到3的全部全排列，手都酸了。可以发现一件事，就是按这种方式写下来的排列，任何一个排列数的下一个排列数必定是唯一的，比如，2031的下一个就是2103，而不会是其他的排列，这就好像任何自然数N的有且必定有唯一一个后继N+1，但是排列数就不一定都有后继了，3210就是最后一个排列数了。于是，我们就可以像普通循环那样写代码了，for(排列对象=0123; 排列对象!=3210; 排列对象.ToNext){输出排列对象}。非常美妙吧，不过当务之急，是先class Permutation。
class Permutation
{
public:
enum {MAX_SIZE = 10};
Permutation(int count)
{
assert(0 < count && count < MAX_SIZE);
m_nCount = (char)count;
for (char i=0; i<m_nCount; i++)
m_Indexs[i] = i;
}
public:
bool ToNext();
char operator[] (int n)const
{
assert(0 <= n && n <= m_nCount);
return m_Indexs[n];
}
private:
char m_Indexs[MAX_SIZE];
char m_nCount;
}; 以上是初版，只支持全排列，部分排列时，它的定义又将不同。我不想再解释它为何是这个样子，请各位用心揣摩，一切都那么必然。我再次用了呆板的数组的定义方式，就好像八皇后那样，因为日常中使用的排列数很少会多于10个的，这一点我很放心，各位也大可以放心。排列后的结果m_Indexs，本来也打算像八皇后那样，直接public出来，但考虑到这个类比八皇后更加通用，而且operator[]确实有点方便使用，写代码时，操作符能不重载就别重载。
接下来，就要对付Permutation.DoNext，也即本文的主角。先考虑一个问题，为什么我们就知道02431的下一个排列必然是03124呢，这里面隐藏着什么奥秘吗？仔细对比02431、03124这两个排列的差异。发现：02431第0位的0没有变，但第1位的2变成了3，02431中2与3交换后，变成了03421。为什么是2呢？在02431中，1<3， 3<4， 但到了2时，则为4>2，所以2成了被指定的那个人。那为什么是3要与2交换呢，因为3后面的1<2，从后往前算，3是第一个比2大的数。所以，2与3交换，理所当然，不可不戒。交换之后，02431变成了03421，再比较03124，就421与124不同，而且还互为逆序，OK，我们找到奥秘了。至于奥秘的理由，里面自有数学原因，但已经无须关心了，我们的职任是编写代码。于是，代码如下。代码就不解释了，请对照上面的描述理解代码。
bool Permutation::ToNext()
{
char nReverse = m_nCount-1;
while (nReverse > 0 && m_Indexs[nReverse]<m_Indexs[nReverse-1])
nReverse--; // 寻找第一个要交换的元素
if (nReverse == 0) // 找不到，表示全排已经完成
return false;
char nSwap = m_nCount - 1;
while (m_Indexs[nSwap] < m_Indexs[nReverse-1])
nSwap--; // 寻找第二个元素
swap(m_Indexs[nReverse-1], m_Indexs[nSwap]); // 开始交换
reverse(m_Indexs+nReverse, m_Indexs+m_nCount); // 逆顺
return true;
}
main也不含糊，只为体现Permutation的用法。
int main()
{
const int N = 3;
Permutation perm(N);
const char* sTests[N] = {"零", "一", "二"};
do
{
for (int i=0; i<N; i++)
cout << sTests[perm[i]] << " ";
cout << endl;
}while(perm.ToNext());
return 0;
}
CLASS真是好东西，如果不用C++，而用C的话，我也不知道代码会是什么样子，起码不会这么易于表达，除了设计好算法和数据结构，还必须多花些心思琢磨代码的设计，这不是一件快乐的事情，而用C++写代码，则非常惬意。
C++是我最喜欢的语言，它集自由、博大、复杂、简约、高效于一身，又能很好地均衡这些特点，使它们和平共处，将“不为用到的任何特性付出一点点代价”的宗旨贯彻到底，其他的任何一种语言的都不具备像C++这样的内涵，使用C++之时，直有C++在手，江山我有的感觉。C虽然能让你掌管一切，但用C开发，有如戴着镣铐在跳舞，无时不刻要小心翼翼地人肉管理一切细节，实在太累了。而用C#、JAVA等其他语言时，虽然养尊处优，但想走不寻常路之时，又处处受限制，很有点寄人篱下的味道，未免不痛快。只有C++，既能下，又能上，进可攻，退可守，想怎么样就怎么样，尽情地飞翔。只要你愿意，你就可以在这一片世界里随心所欲地发挥你的一切聪明才智，创造出种种奇技淫巧，而不会受到一点点约束。问题来了，自由得过头了，就失去了控制，自由未必是好事。好多人，自由得甚至忘记了他要用C++的根本目的是什么，于是，C++到了他的手里，就变成为自由而自由，为复杂而复杂的利器，不但用它来折磨自己，还用它来迷惑别人，以致于忽视了原本要解决的问题，这样一来，问题就很严重了。好的工具本来就是要用来做点实事的，做不了实事，要拿什么来证明自己呢？
对于C++，没什么好说的。但C++的教育，就有太多的不满，要指责之处，也实在太多了，其中最为人诟病，就是很多C++的教材，都鼓励读者将注意力集中到C++的细节中，而忘记了如何用C++来简洁质朴地来表达设计思路。关于这一点，很多达人君子也已经一再严厉地批评再批评。我也不想重复他们的论调，只想举两个例子。
C++因缺乏GC，而广受非议。但内存管理，其实不值得议论再议论，只要设计编写得当，少耍小聪明，代码中出现new和delete的次数可以很少很少，就算出现，也只会出现于底层代码中。为了弥补GC的缺席，C++界中发明了种种内存管理的巧妙手法，其中最得力的一种办法就是智能指针，而出现于标准库中就是大名鼎鼎的auto_ptr了，甚至有人说，一本C++的教材，只要不介绍auto_ptr，就不属于合格的教科书。但其实，auto_ptr并不见得那么重要，好比以下的代码
Int* pa = new int;
……
delete pa;
这代码确实不好，于是该auto_ptr上场表演，变成
auto_ptr<int*> pa(new int);
delete消失了，何其美妙，但其实，最朴实的代码，连new都可以不用的，既然没有new，就不需要auto_ptr了，最简洁的代码，非常简单。
Int a = 0;
一行就好，什么都用不了，很多出现auto_ptr的地方，直接用局部变量就可以了。不能使用局部变量的地方，就属复杂的内存管理了，在那里分配，在那里释放，都很有必要细细地斟酌一番，auto_ptr并非什么万能丹，一有内存分配，就搬出auto_ptr，只怕属本本主义的作风。即此以观，什么share_ptr，scope_ptr，也就那么一点点作用而已，无须大书特书。
我承认，BOOST精妙无比，那都是C++程序聪明才智的结晶，但其实，真正搬得上台面，发挥大作用的玩意，为数并不多，好比Tuple，可以方便地返回函数中的多个结果，例如……（请大家自己动手，或baidu或google），乍听起来，似乎美妙无比。但其实，没什么作用，什么时候，我们需要从函数中返回多个值？需要从函数中返回多值时，我会尽量地写本地代码，实在必须调用函数了，只好搬出指针或引用，将参数传递进去，如果数量太多了，那就动用结构，用结构组织这些返回值，这一切，做起来，并没什么太大的不便。但是如果动用Tuple返回多个结果，可能方便了那么一点点，却将导致代码难以维护，因为Tuple里面的值各表示了什么意思，无法直接从代码中看得出来，用过Tuple的同学自然知道我要说什么。Tuple的实现非常巧妙，如此费尽心思弄出来的东西，不过是一只漂亮花瓶而已，真让人扼腕叹息不已，很多C++的库，尤其是BOOST，都是这个样子，看起来很精致，用起来，却完全不是那么一回事，而且还引入很多不必要复杂性，世人称心智包袱。
……
用C++做设计，很容易就导致库设计，如果设计出来的库有用好用，那也罢了，问题是费了九牛二虎之力，搞出来的东西，半点得不到别人的认可，甚至连自己都无法认可，那就太不应该了。
用C++写代码，老老实实地写代码，不要忘记了编程的用意，别沉浸于语言中，尽量将代码写得直白易懂，少卖弄聪明才智， 慎用C++的一切特性，继承、虚函数、操作符重载、模板、异常、new delete、……，更加不要用它们创造出什么奇技淫巧，必须用它们的时候，必须要有使用它们的理由。确实存在必须使用它们的理由，还坚决不用，那就是傻瓜和偏执狂了，这不是合格的C++码农，C++虽然不喜欢胡作非为的捣蛋鬼，但也杜绝一切墨守成规的书呆子。