非模板结构/类的模板成员函数-默认类型是什么？

Question

I've seen code like this:

#include <iostream>

// member_function_templates.cpp
struct X
{
   template <class T> void mf(T* t) {
     std::cout << "in mf t is: " << *t << std::endl;
   }
};

int main()
{
   int i = 5;
   X* x = new X();
   x->mf(&i); //why can this be called without specifying a type as in: x->mf<int>(&i) ??
}

My question is in the comment there in main. Why can you call:

x->mf(&i);

...without specifying a type? Intuition says it should be called like:

x->mf<int>(&i);

... but apparently does not have to be called like this (the above compiles with gcc 4.7 for me either way - with of without explicitly specifying the template.)

And, if you call it without specifying a type for the template, what will the type of T be (in the template function definition)? (I'm guessing it defaults to the type of whatever it is you pass into the function mf as an argument, but further explanation of how this works would be nice)

Answer 1

That is template type deduction and it applies to all template functions, not just members of a non-templated class. Basically the compiler is able to infer (following a set of rules in the standard) what the type T means from the arguments to the function. When the compiler sees the call to mf(&i); , it knows that i is an int , so the argument is an int* and that means that you want the overload that has T==int ^(*)

You can still provide a particular set of template arguments if you want to force a particular specialization of the template. If, for example, you want the parameter to the template not be the deduced one, but one that is convertible from it:

template<typename T>
void foo(T arg) {...}

int i = 10;
foo(i);             // calls foo<int>(i)
foo<double>(i);     // calls foo<double>(static_cast<double>(i))

^(*) It is slightly more complicated than this, as there could be potentially multiple T types for which the argument would be valid, but the rules in the language determine what particular T will be deduced . In this case, it is int .