代码编译在gcc上，但不在msvc上编译

Question

I have a problem compiling a template using msvc-2010. It works perfectly using gcc 4.6.3.

I have boiled down the code to the essential (it doesn't make sense of course):

//Variant that works
template <typename T, T* Ptr>
void callFun()
{
}

//Traits class (type expands to the same type T* as above)
template <typename T>
class TraitsClass
{
public:
    typedef T* type;
};

//Essentially the same as callFun2, only that the
//type of Ptr is expressed indirectly over a traits class
//The usage of this class is not possible, because of the error described below
template <typename T, typename TraitsClass<T>::type Ptr>
void callFun2()
{
}

//Provides a compile constant ptr for this example
void testFun()
{
}

int main()
{
    //Works
    callFun<void(), &testFun>();

    //Fails
    callFun2<void(), &testFun>();

    //Works
    callFun2<void(), 0>();

    return 0;
}

The Error:

error C2975: 'Ptr' : invalid template argument for 'callFun2', expected compile-time constant expression

I find it interesting, that it only fails when the second type parameter is being used through a typedef in a Traits class. g++ compiles this example correctly without warnings, even when using -Wall -Wextra -Werror -pedantic (Except for the unused parameters, of course)

Thank you very much.

Answer 1

Well, I think that the answer is that compilers are not written by gods. Programming standards in the compiler industry are extremely high, MS C++ is a good compiler, but it still contain bugs. I came across the following, that is somehow similar to what you are pointing at:

template <class item_struct>
struct THeapBasedArray
{
    void  Sort(int (__cdecl *compareFunction)(const item_struct *item1,
                                              const item_struct *item2));
};

struct Item { int x; };

struct ItemPtrsArray : public THeapBasedArray<Item*>
{
    static int __cdecl  Compare1(const Item **pp1, const Item **pp2);

    typedef Item *ItemPtr;
    static int __cdecl  Compare2(const ItemPtr *pp1, const ItemPtr *pp2);
};

int main()
{
    ItemPtrsArray vect;

    vect.Sort(ItemPtrsArray::Compare1);
    vect.Sort(ItemPtrsArray::Compare2);
}

The first call to Sort fails with:

cpptest1.cxx(21) : error C2664: 'THeapBasedArray::Sort' : cannot convert parameter 1 from 'int (_ cdecl *)(const Item **, const Item **)' to 'int ( _cdecl *)(const item_struct *, const item_struct *)

while the second call compilers fine. For me this is a bug in a compiler. Sometimes this happens. I guess this is the answer.