C++——模板

template <typename T> void f1(T&);//实参必须是左值
f1(i);//对
f1(ci);//对，T的类型是const int
f1(5);//错
template <typename T> void f2(const T&);//实参可以是左值，const右值
f2(i);//对
f2(ci);//对
f2(5);//对
template <typename T> void f3(T&&);//实参只能是非const右值

template <typename T> void f3(T&& val)
{
    T t=val;//拷贝还是绑定一个引用？
    t=fcn(t);//赋值只改变t还是t和val都变？
    if (val == t)//若t是引用类型，则一直为true
    ……
}
//看传入的值
1.如果传入值是右值，如字面常量，T为int。此时t的类型也为int，通过val初始化，参数val保持不变
2.如果传入值是左值，T为int&？？？此时t的类型也为int&，则变t也变val

template <typename T> typename remove_reference<T>::type&& move(T&& t)
{
    return static_cast<typename remove_reference<T>::type&&>(t);
}

template <typename F,typename T1,typename T2> void flip1(F f,T1 t1,T2 t2)
{
    f(t2,t1);
}
void f(int v1,int &v2)
{
}
//
f(42,i)
flip1(f,j,42);//没有发挥引用的效果

template <typename F,typename T2> void flip1(F f,T1&& t1,T2&& t2)
{
    f(t2,t1);
}

template <typename F,T2&& t2)
{
    f(std::forward<T2>(t2),std::forward<T1>(t1));//显式模版实参类型
}

//1.
template <typename T> string debug_rep(const T& t)
{
  stream ret;
  ret<<t;
  return ret.str();      
}
//2.
template <typename T> string debug_rep(T* p)
{
  stream ret;
  ret<<"pointer is: "<<p;
  if (p)
      ret<<" "<<debug_rep(*p);
  else
      ret<<" null ptr"<<;
  return ret.str();      
}
//调用
string s("hi");
cout<<debug_rep(s)<<endl;//只有第一个版本可行
cout<<debug_rep(&s)<<endl;//第一个版本实例化为：debug_rep(const string*&),T类型为string*
                          //第二个版本实例化为：debug_rep(string*)，T类型为string　　更精确，编译器选择第二个

const string *sp=&s;
cout<<debug_rep(sp)<<endl;//第一个版本实例化为：debug_rep(const string*&),T类型为string*
                          //第二个版本实例化为：debug_rep(const string*)，T类型为const string，更特列化，选择第二个

template <typename T,typename ... Args> viod foo(const T& t,const Args& ... rest)
{
　　cout<<sizeof...(Args)<<endl;//类型参数的数目
　　cout<<sizeof...(rest）<<endl;//函数参数的数目
}
//
int i=0; double d=3.14; string s="stringiest ";
foo(i,s,42,d);　　//参数包有3个参数
foo(s,42,"hi");　//参数包有2个参数
foo(d,s);　　　　//参数包有1个参数
foo("hi");　　 //参数包有0个参数
//实例化版本
void foo(const int&,const string&,const int&,const double&);
void foo(const string&,const char[3]&);
void foo(const double&,const string&);
void foo(const char[3]&);

template<typename T> ostream &print(ostream &os,const T& t)//打印最后一个元素
{
    return os<<t;
}
template <typename T,typename... Args> ostream &print(ostream& os,const T& t,const Args&... rest)
{
    os<<t<<",";
    return print(os,rest ...);//递归调用
}

template <typename T> int compare(const T&,const T&);
template <size_t N,size_t M> int compare(const char (&)[N],const char (&)[M]);
const char* p1="hi",*p2="mom"；
compare(p1,p2);//调用第一个版本
compare("hi","mom");//调用两个版本

template <> int compare(const char* const &p1,const char* const &p2)
{
    return strcmp(p1,p2);
}
//此特例化，是为了处理字符指针，而不是数组