C++模板&泛型编程

 定义模板关键字：T是模板参数名字可以任意命名，下面代码返回值是T类型这个很重要
 1 template<typename T>
 2 T Add(T left,T right)
 3 {
 4     return left+right;
 5 }
 6 
 7 int main()
 8 {
 9     cout<<Add(1,2)<<endl;;
10     return 0;
11 }
//给main()函数里加一句cout<<Add(1.2,2.3)<<endl;函数模板将被编译两次
// 1.实类化之前，检查模板代码本身，查看是否出现语法错误，如：遗漏分号。2.在实类化期间，检查模板代码，查看是否所有的调用都有效，如：实类化理性不支持某些函数调用 

这个返回值是T1，配合下面代码就是int ，函数返回值类型很重要，所以这里还是认真点
 1 template<typename T1,typename T2>
 2 T1 Add(T1 left,T2 right)
 3 {
 4     return left+right;
 5 }
 6 
 7 int main()
 8 {
 9     cout<<Add(1,‘2‘)<<endl;;
10     return 0;
11 }

 1 template<typename T1,typename T2>
 2 inline T2 Add(T1 left,T2 right)
 3 {
 4     return left+right;
 5 }
 6 
 7 int main()
 8 {
 9     cout<<Add(1,‘2‘)<<endl;;
10     return 0;
11 }
12 //返回值是字符3

//模板形参名字只能在模板形参之后到模板声明或定义的末尾之间使用，遵循名字屏蔽规则
 1 typedef int T;
 2 template<typename T>
 3 void FunTest(T t)
 4 {
 5     cout<<"t type = "<<typeid(t).name()<<endl;
 6 }
 7 T gloab;
 8 int main()
 9 {
10     FunTest(10);
11     cout<<"gloab type = "<<typeid(gloab).name()<<endl;
12     return 0;
13 }

 1 //template<class T,U,typename V>
 2 //void F1(T,U,V);
 3 //模板参数不能这样定义,模板参数前必须加上定义模板参数关键字class或者typeame
 4 //template<class T>
 5 //T F2(int &T);
 6 
 7 //template<class T>
 8 //T F3(T,T);
 9 //typedef int TYPENAME;
10 //template<typename TYPENAME>
11 //TYPENAME F4(TYPENAME);

 主要看看下列情况调用哪个函数
 1 int Max(const int& left,const int& right)//1
 2 {
 3     return (left>right)?left:right;
 4 }
 5 template<typename T>                     //2
 6 T Max(const T& left,const T&right)
 7 {
 8     return (left>right)?left:right;
 9 }
10 template<typename T>                     //3
11 T Max(const T& a,const T& b,const T& c)
12 {
13     return Max(Max(a,b),c);
14 }
15 int main()
16 {
17     Max(10,20,30);//3
18     Max<>(10,20);//2
19     Max(10,20); //1
20     Max(10,20.0);//1
21     Max<int>(10.0,20.0);//2
22     Max(10.0,20.0);//2
23     return 0;
24 }
//注意：函数的所有重载版本的是声明都应该位于该函数被调用位置之前

 1 template<class T>
 2 int compare(T t1,T t2)
 3 {
 4     if(t1>t2)
 5         return 1;
 6     else if(t1<t2)
 7         return -1;
 8     else
 9         return 0;
10 }
11 int main()
12 {
13     char *pStr1="holle";
14     char *pStr2="world";
15     cout<<compare(pStr1,pStr2)<<endl;        
16     return 0;
17 }
//结果是1,实际是-1

eg:
1 template<typename T>
2 class SeqList
3 {
4 private:
5     T* _Data;
6     int _size;
7     int _capacity
8 }

 1 //以模板方式实现动态顺序表
 2 
 3 template<typename T>
 4 class SeqList
 5 {
 6 public:
 7     SeqList();
 8     ~SeqList();
 9 private:
10     int _size;
11     int _capacity;
12     T* _Data;
13 };
14 template<typename T>
15 SeqList<T>::SeqList()
16 :_size(0)
17 ,_capacity(10)
18 ,_Data(new T[_capacity])
19 {}
20 template<typename T>
21 SeqList<T>::~SeqList()
22 {
23     delete []_Data;
24 }
25 void FunTest()
26 {
27     //SeqList Seq;
28     SeqList<int>s1;
29     SeqList<double>s2;
30 }
//有一种不同的类型编译器就会实类化出对应的一个类