Question

Possible Duplicate:
Using template parameters as template parameters

Here’s a code snippet of some heavily templated container classes used to bind an arbitrary amount of fields of arbitrary types. A co-worker of mine found that my code didn’t compile under GCC and after much research he found the fix to get it to deduce the templates correctly by adding ::template … Neither of us had ever seen this before and still don’t really know what this is other than something that GCC needs for my code that Visual Studio 2010 does not need.

    template< typename T, int N >
    struct SingleBindMemberStruct
    {
        typedef typename TGenericBindingHandler<T>::BindToUse BindType;
        BindType m_Member;

        template< typename ContainerClass >
        static void AddBinding(CPackedTableDataSpec* spec)
        {
// Perhaps with newer versions of the compilers we can find a syntax that both accept. This is with gcc-4.5 and Visual Studio 2010
#if defined(__GNUC__)
            TGenericBindingHandler<T>::template AddBinding<ContainerClass>(spec, N, &ContainerClass::template SingleBindMemberStruct<T,N>::m_Member);
#else
            TGenericBindingHandler<T>::template AddBinding<ContainerClass>(spec, N, &ContainerClass::SingleBindMemberStruct<T,N>::m_Member);
#endif
        }
    };

Does anyone know syntactically what ::template can or should be used for? If anyone has a snippet from the standard that describes it that would be perfect!

Edit:

Alright so sounds like it is really as simple as helping the compiler determine what is a template and since this is a static function we use the scope resolution operator rather than the dot operator to tell the compiler of the template. So now the only remaining question is why does Visual Studio not need this as well?

Answer 1

It tells the compiler that AddBinding is a template — since the definition of AddBinding is dependent on T, the compiler wouldn’t otherwise know this at the right stage of the compilation process (I’m no expert on the details, but it’s to do with the C++ compilation model AFAIK). By writing template after the ::, you give the compiler information it otherwise wouldn’t have. I guess more specifically, it knows that it’s dealing with a template and not a < operator when it sees < after AddBinding.

If you want a more detailed answer, you might want to check out C++ Templates: The Complete Guide. (I think it’s available as a PDF if you search Google.)