试题:编译期确定template <typename U, typename V>中U, V是否为同类型

我们知道int array[sizeof(int)];之所以能正常编译是因为sizeof(int)的结果在编译期就会被确定下来
另外, int array[sizeof(0)];也可以正常编译, 因为sizeof的真正操作"参数"是类型, 不是值, 所以这句对编译器来说就是前面那句
我们先定义一个函数:
int getzero() { return 0; }, 我们再定义array如右: int array[sizeof(getzero())]; 我们发现它仍然可以通过编译, 这是因为sizeof只认类型, 不认值, 我们再去掉getzero的定义, 只留声明: int getzero(); 并重新定义array: int array[getzero()]; 仍然可以编译通过, 还是那句: sizeof操作符只认类型, 不认值
下面是我在大学期间的笔记本上看到的一份对题目的实现方案(略加修改):

#include <iostream>using namespace std;template <typename U, typename V>class TypeAssert{private:    typedef char small_type;    typedef long large_type;    static small_type getType(U);    static large_type getType(...);    static V getVType();    enum { type_equal = (sizeof(getType(getVType())) == sizeof(small_type)) };public:    static void show_type()    {        cout << "U" << (type_equal ? " == " : " != ") << "V" << endl;    }};int main(){    TypeAssert<int, long>::show_type();    TypeAssert<int, char>::show_type();    TypeAssert<int, double>::show_type();    TypeAssert<int, int>::show_type();    TypeAssert<int, char *>::show_type();    return 0;}

关于里面的前三个函数都是static的解释:

如果前三个函数不是static的, 那么enum中用到这个三个函数是怎么来的, 用它一定要有对象(或this指针), 然而enum是属于类的, 不是对象的成员, enum中不会有this这个指针, 所以要想通过编译, 前三个函数必须是static的, static函数不须要有对象作隐式参数

最后的函数定义成static的是因为我不想以对象的方式来调用它

代码的目的很明确, 如果V和U是同类型, 则getType(getVType())调用的是参数为U类型的getType, 否则调用的为可变参数的getType,
想法很好, 编译也正常, 运行后得到结果打印如下:

U == V
U == V
U == V
U == V
U != V

这是怎么回事?
我马上写了如下测试代码:

#include <iostream>using namespace std;void test(int){    cout << "int" << endl;}void test(...){    cout << "..." << endl;}int main(){    test(static_cast<long>(0));    test(static_cast<char>(0));    test(static_cast<double>(0));    test(static_cast<int>(0));    test(static_cast<char *>(0));    return 0;}

运行打印:

int
int
int
int
...

哦, 原来, 只要V可以隐式的转化为U就会调用参数为U类型的getType, 看来原代码的作者没有在多环境下测试啊
眼下的问题是, 我们应该怎么改呢?
说到底, 是可恶的隐式转换搅了局

我很快想到这么个问题: D是B的公有子类时, D到B就会存在隐式转换, 我们很乐意这样, 可是以B和D为类型参数的模板类Template<B>与Template<D>却不存在这种父子关系, 这也让我们不能简单的进行Template<D>到Template<B>的赋值(隐式转换), 当初我们可能还埋怨这个性质, 现在是利用它的时候了, 其实不管B与D存在什么样的关系, Template<B>与Template<D>都会把这种关系打破, 当然有办法可以保持部分像B与D一样的关系, 下面是我做的修改, 我在TypeAssert中定义了一个内部的模板类Tproxy, 这个类什么事也不做, 且看修改后的代码:

#include <iostream>using namespace std;template <typename U, typename V>class TypeAssert{private:    template<typename T>    class Tproxy    {    };private:    typedef char small_type;    typedef long large_type;    static small_type getType(Tproxy<U>);    static large_type getType(...);    static Tproxy<V> getVProxy();    enum { type_equal = sizeof(getType(getVProxy())) == sizeof(small_type) };public:    static void show_type()    {        cout << "U" << (type_equal ? " == " : " != ") << "V" << endl;    }};int main(){    TypeAssert<int, long>::show_type();    TypeAssert<int, char>::show_type();    TypeAssert<int, double>::show_type();    TypeAssert<int, int>::show_type();    TypeAssert<int, char *>::show_type();    return 0;}

编译正常, 运行结果:

U != V
U != V
U != V
U == V
U != V

这正是我们想要的!