You can use the following syntax in Class.cpp: template void Class::function(int); The template argument can be omitted because of type deduction, which works for function templates. Thus, the above is equivalent to the following, just more concise: template void Class::function<int>(int); Notice, that it is not necessary to specify the names of the function parameters – … Read more
There is no way to explicitly specify the template arguments when calling a constructor template, so they have to be deduced through argument deduction. This is because if you say: Foo<int> f = Foo<int>(); The <int> is the template argument list for the type Foo, not for its constructor. There’s nowhere for the constructor template’s … Read more
AFAIK that’s changed in C++0x. I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member of a class). You might look up the relevant DR (Defect Report), if there is one. EDIT: checking this, I find … Read more
I suspect the answer is “you cannot do this”. Yes, that is the case, you cannot pass a function template as a template argument. From 14.3.3: A template-argument for a template template-parameter shall be the name of a class template or an alias template, expressed as id-expression. The template function needs to be instantiated before … Read more
As far as I know non-template function is always preferred to template function during overload resolution. This is true, only when the specialization and the non template are exactly the same. This is not the case here though. When you call uct u3(u1) The overload sets gets uct(const uct &) uct(uct &) // from the … Read more
For foo<int>(a), ARG_T is being deduced from a, and is not taken from the default template argument. Since it’s a by value function parameter, and a is an expression of type int, it’s deduced as int. In general, default template arguments are not used when template argument deduction can discover what the argument is. But … Read more
Welcome to const and reference collapsing. When you have const T&, the reference gets applied to T, and so does the const. You call g like g<int&>(n); so you have specified that T is a int&. When we apply a reference to an lvalue reference, the two references collapse to a single one, so int& … Read more
AFAIK that’s changed in C++0x. I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member of a class). You might look up the relevant DR (Defect Report), if there is one. EDIT: checking this, I find … Read more
Write this: template <class T> template <class U> void MyClass<T>::foo() { /* … */ }
Templates are all about the compiler generating code at compile-time. Virtual functions are all about the run-time system figuring out which function to call at run-time. Once the run-time system figured out it would need to call a templatized virtual function, compilation is all done and the compiler cannot generate the appropriate instance anymore. Therefore … Read more