Template instantiation with VARIANT return type.

Question

An explicit instantiation of a static template member function keeps failing to compile with the message error C2785: 'at_Intermediate CUtil::convert_variant(const VARIANT &)' and '<Unknown>' have different return types

When I make a corresponding class with non-static member functions, the compiler likes me.

// utility class - static methods
struct CUtil {
      template< typename at_Intermediate > static at_Intermediate convert_variant( const VARIANT &v ) ;

      template<> static VARIANT convert_variant<VARIANT >( const VARIANT &v ) { return v; } // 
      template<> static double  convert_variant<double  >( const VARIANT &v ) { return v.dblVal; }
      template<> static long    convert_variant<long    >( const VARIANT &v ) { return v.lVal  ; }
      template<> static BSTR    convert_variant<BSTR    >( const VARIANT &v ) { return v.bstrVal; }
};

This is a composed question:

1. Why does the compiler complain about a function "Unknown" while it's clearly known?

2. What triggers this message - it disappears when the function is made global or non-static.

EDIT:

after some useful hints from Josh: is it not allowed to explicitly instantiate template functions within the class declaration?

Answer 1

Try it this way:

struct CUtil {
    template< typename T > 
    static T convert_variant(const VARIANT &);
};

template<> int CUtil::convert_variant<int>(const VARIANT &);
template<> VARIANT CUtil::convert_variant<VARIANT>(const VARIANT &);

You can't explicitly specialize a template inside a class scope. See here.

The wierd issue with VS2008 is that this does work.

struct CUtil {
    template< typename T > 
    static T convert_variant(const VARIANT &);
    template<> 
    static int convert_variant<int>(const VARIANT &);
};

And this:

struct CUtil {
    template< typename T > static void convert_variant(T);
    template<> static void convert_variant<VARIANT >(VARIANT);
};

Answer 2

Apparently you may only use explicit template specialization at namespace scope although I can't find this in the standard (but GCC says as much). The following works for me (on GCC):

struct CUtil {
    template< typename at_Intermediate > static at_Intermediate convert_variant( const VARIANT &v ) ;
};

template<> VARIANT CUtil::convert_variant<VARIANT >( const VARIANT &v ) { return v; }
template<> double  CUtil::convert_variant<double  >( const VARIANT &v ) { return v.dblVal; }
template<> long    CUtil::convert_variant<long    >( const VARIANT &v ) { return v.lVal  ; }
template<> BSTR    CUtil::convert_variant<BSTR    >( const VARIANT &v ) { return v.bstrVal; }

EDIT It is in the standard:

14.7.2.5:

An explicit instantiation of a class or function template specialization is placed in the namespace in which the template is defined. An explicit instantiation for a member of a class template is placed in the namespace where the enclosing class is defined. An explicit instantiation for a member template is placed in the namespace where the enclosing class or class template is defined.

(All emphasis added by me.)