快速抢答：什么是“零”？
更明确地说，下面的代码会发生什么？
|
1 2 3 4 |
void f(int x); void f(string *ps); f(0); // 调用f(int)还是f(string*)? |
答案是，0是一个int——准确地说，一个字面上的整数常量——所以，“总是”f(int)被调用。这就是问题所在：因为不是所有的人总是希望它这样执行。这是c++世界中特有的一种情况：当人们认为某个调用应该具有多义性时，编译器却不这么干。
如果能想办法用符号名（比如，null表示null指针）来解决这类问题就好了，但实现起来比想象的要难得多。
|
1 2 3 4 5 6 7 8 9 10 11 |
void * const null = 0; // 可能的null定义 f(0); // 还是调用f(int) f(static_cast(null)); // 调用f(string*) f(static_cast(0)); // 调用f(string*) 不过细想一下，用null来表示一个void*常量的方法还是比最初要好一点，因为如果能保证只是用null来表示null指针的话，是可以避免歧义的： f(0); // 调用f(int) f(null); // 错误! — 类型不匹配 f(static_cast(null)); // 正确, 调用f(string*) |
至少现在已经把一个运行时的错误（对0调用了“错误的”f函数）转移成了一个编译时的错误（传递一个void*给string*参数）。情况稍微有点改善（宁可编译和链接时出错，也不要运行时出错），但需要进行类型转换还是令人讨厌。
如果想可耻地退回去求助于欲处理，你会发现它也解决不了问题，因为最明显的办法不外乎：
|
1 2 3 4 5 |
#define null 0 或 #define null ((void*) 0) |
第一种办法只不过是字面上的0，本质上还是一个整数常量（如果你记得的话，还是最初的问题）；第二种方法则又把你拉回到“传void*指针给某种类型的指针”的麻烦中。
如果对类型转换的规则有研究，你就会知道，c++会认为“从long int 0到null指针的转换”和“从long int到int的转换”一样，没什么不妥的。所以可以利用这一点，将多义性引入到上面那个你可能认为有“int/指针”问题的地方：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#define null 0l // null现在是一个long int void f(int x); void f(string *p); f(null); // 错误!——歧义 然而，当想重载long int和指针时，它又不起作用了： #define null 0l void f(long int x); // 这个f现在的参数为long void f(string *p); f(null); // 正确, 调用f(long int) |
实际编程中，这比把null定义为int可能要安全，但它无非只是在转移问题，而不是消除问题。
这个问题可以消除，但需要使用c++语言最新增加的一个特性：成员函数模板（往往简称为成员模板）。顾名思义，成员函数模板是在类的内部为类生成成员函数的模板。拿上面关于null的讨论来说，我们需要一个“对每一个t类型，运作起来都象static_cast<t*>(0)表达式”的对象。即，使null成为一个“包含一个隐式类型转换运算符”的类的对象，这个类型转换运算符可以适用于每种可能的指针类型。这就需要很多转换运算符，但它们可以求助于c++从成员模板生成：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// 一个可以产生null指针对象的类的第一步设计 class nullclass { public: class nullclass { public: template // 为所有类型的t operator t*() const { return 0; } // 产生operator t*； }; // 每个函数返回一个 // null指针 // const nullclass null; // null是类型nullclass // 的一个对象 void f(int x); // 和以前一样 void f(string *p); // 同上 f(null); // 将null转换为string*, // 然后调用f(string*) |
这是一个很好的初步设计，但还可以从几方面进行改进。第一，我们实际上只需要一个nullclass对象，所以给这个类一个名字没必要；我们只需要定义一个匿名类并使null成为这种类型。第二，既然我们是想让null可以转换为任何类型的指针，那就也要能够处理成员指针。这就需要定义第二个成员模板，它的作用是为所有的类c和所有的类型t，将0转换为类型t c::*（指向类 c里类型为t的成员）。（如果你不懂成员指针，或者你从没听说过，或很少用，那也不要紧。成员指针可以称得上是稀有动物，是很少见，也许很多人从来没用过它。对此好奇的人可以参考其返回值是指向成员的非const指针或引用，但成员的访问级比这个函数要低，那儿对成员指针进行了较详细的讨论。）最后，要防止用户取null的地址，因为我们希望null的行为并不是象指针那样，而是要象指针的值，而指针的值（如0x453ab002）是没有地址的。
所以，改进后的null的定义看起来就象这样：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
const // 这是一个const对象... class { public: template // 可以转换任何类型 operator t*() const // 的null非成员指针 { return 0; } // template // 可以转换任何类型 operator t c::*() const // 的null成员指针 { return 0; } private: void operator&() const; // 不能取其地址 // } null; // 名字为null |
这就是所看到的真实的代码，虽然在实际编程中有可能想给类一个名字。如果不给名字，编译器里指向null类型的信息也确实很难理解。
重要的一点是，以上所有那些产生正确工作的null的设计方案，只有在你自己是调用者的时候才有意义。如果你是设计被调用函数的人，写这样一个给别人使用的null其实没有多大的用处，因为你不能强迫你的调用者去使用它。例如，即使为你的用户提供了上面开发的那个null，你还是不能防止他们这样做：
|
1 2 3 |
f(0); // 还是调用f(int), // 因为0还是int |
它还是和本条款最前面的出现的问题一样。
所以，作为重载函数的设计者，归根结底最基本的一条是，只要有可能，就要避免对一个数字和一个指针类型重载。