20120906

 1 template <int N>
 2 class X {
 3 public:
 4     typedef int I;
 5     void f(int) {
 6         std::cout << "f!" << std::endl;
 7     }
 8 };
 9 
10 template <int N>
11 void fppm (void (X<N>::*p)(typename X<N>::I) );        //此处调用了一个函数
12 
13 int main() {
14     fppm(&X<33>::f);
15 }

上面第11行的调用中，fppm的参数是一个函数。 void 是返回值， (X<N>::*p) 是函数名， (typename X<N>::I>)是函数的参数，对应第4行的定义 X<N>::I 可知此处表示 int

因此对11行相当于 void fppm (void f(int) )

 1 template <typename T>
 2 void f(T){
 3     std::cout << "T" << std::endl;
 4 }
 5 template<>
 6 void f(double) {
 7     std::cout << "double" << std::endl;
 8 };
 9 
10 void (*df) (double) = &f;       //此处实例化了一个double版的 f 函数
11 
12 df(111);                        //输出 double
13 df('a');                        //输出 double   
14 df(2.33);                       //输出 double

模版实参演绎只能应用于函数模版和成员函数模版，不能应用于类模版。对于类模版的构造函数也不能根据实参来演绎类模版参数。只能手工指定。

函数模版可以指定缺省函数调用实参，但不能根据缺省实参演绎模版参数。

template<typename T>
void init(T* loc, T const& val = T() ){
    *loc = val;
}

init(12, 13);                   //指定参数，未调用缺省值
init(12);                       //为指定第二个参数，调用缺省值，模版参数根据第一个参数演绎

template<typename T>
void f (T x = 11){
}

f<int> ();                     //模版参数指定为int，调用缺省值x=11
f ();                          //错误，模版参数无法根据缺省值演绎