Quote:Original post by samv
Instead of partial template specialization, try simple overloading. This should even work in 7.1.
*** Source Snippet Removed ***

template < class R >void expose( const std::string& name, R( *func )( void ) ) {	details::CFuncStub stub;	stub.func = func;	stub.call = &details::_ArgParser<R>::parseNoArgs;	details::_addCFunc( name, stub );}template < class R, class A1 >void expose( const std::string& name, R( *func )( A1 ) ) {	details::CFuncStub stub;	stub.func = func;	stub.call = &details::_ArgParser<R>::parse<A1>;	details::_addCFunc( name, stub );}

template < class R >struct _ArgParser {	template < class A1 >	static PyObject* parse( PyObject* args, void* func, A1* unused = 0 ) {		// body unchanged	}	template <>	static PyObject* parse<void>( PyObject* args, void* func, void* unused = 0 ) {		// body unchanged	}};

template < class R >struct _ArgParser {	template<typename A1>	struct RetVal {		static PyObject* parse( PyObject* args, void* func ) {			// body unchanged		};	};	template <>	struct RetVal<void> {		static PyObject* parse( PyObject* args, void* func ) {			// body unchanged		};	};};

details::_ArgParser<R>::Retval<A1>::parse

Quote:Original post by NotAYakk
Note that your "fix" is incomplete. Try making a function that returns a double and another that returns on int -- only one version of "parse" will be created (either the int or double one) and will be called in both cases.

Quote:I'm really sleepy right now. Anyway, each templated function (even though they have the same signature) resides in a separate class namespace, so I would assume it to be different.

If you're saying that

&_ArgParser<int>::parseNoArgs == &_ArgParser<double>::parseNoArgs

then, like PM me or something and I'll stop using VC7 altogether and burn the CDs in a giant pyre of shame. Because that's a stupidity that I honestly can't live with.

template<typename A>void foo() {  printf("default version! %d\n", sizeof(A));}template<>void foo<int>() {  printf("int version!\n %d\n", sizeof(A));}template<>void foo<double>() {  printf("double version!\n %d\n", sizeof(A));}int main() {  foo<char>();  foo<int>();  foo<double>();  foo<long>();}

&foo<long> == &foo<char>

default version! 1int version!4double version!8default version! 4