试题:编译期确定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

这正是我们想要的!