Re: VC++ 6.0 workaround for partial specialization
Matthias Hofmann wrote:
I am working on a project on Visual C++ 6.0 and I need to port some code
that uses partial specialization of class templates:
My spontaneous response to this is: Forget it and get an at least halfway
modern compiler!
Anyway, let's see...
// Extracts the type of an object.
template <class T>
struct extract { typedef T type; };
// Extracts the type of an array.
template <class T, std::size_t N>
struct extract<T[N]> { typedef T type; };
[...]
// Forwards the call to helper classes.
template <class T> typename extract<T>::type* TrackNew(
typename extract<T>::type* ptr, const char* file, int line )
{
return TrackNewHelper<T>::TrackNew( ptr, file, line );
}
#define NEW( T ) TrackNew<T>( new T, __FILE__, __LINE__ )
VC6 (or, rather, MSC12) can't cope with functions overloaded only by their
template parameters or their returntype. Example:
template<typename R> R get_value() { return R(); }
Normally, you could use it like this:
int i = get_value<int>();
double d = get_value<double>();
....which VC6 happily compiles and links, only to either call the int or
double variant at runtime. The other variant is simply not part of the
executable because it is a function with the same name and same parameters.
Now, the workaround for that is:
#if defined(_MSC_VER) && _MSC_VER<1300
// workaround for MSC12 not mangling template parameters into
// generated function symbols
template<typename R> R get_value( R* dummy=0) { return R(); }
#else
template<typename R> R get_value() { return R(); }
#endif
IOW, you artificially add a parameter to the function that uses the template
parameter, causing the compiler to emit different symbols for different
instantiations.
I hope I understood your problem correctly, the problem is your code
contains too much additional stuff and lacks an error description...
good luck!
Uli