25.C++- 泛型编程之函数模板(详解)

void Swap(int& a, int& b)
{
    int c = a;
    a = b;
    b = c;
}

template <typename T>       //声明使用模板,并定义T是一个模板类型

void Swap(T& a, T& b)           //紧接着使用T
{
    T c = a;
    a = b;
    b = c;
} 

int a=0;
int b=1;

Swap(a,b);                   //自动调用,编译器根据a和b的类型来推导

float c=0;
float d=1;

Swap<float>(c,d);           //显示调用,告诉编译器,调用的参数是float类型

#include <iostream>
#include <string>

using namespace std;

template < typename T >
void Sort(T a[], int len)
{
       for(int i=1;i<len;i++)
       for(int j=0;j<i;j++)
       if(a[i]<a[j])
       {
               T t=a[i];
               a[i]=a[j];
               a[j]=t;
       }
}

template < typename T >
void Println(T a[], int len)
{
     for(int i=0; i<len; i++)
    {
        cout << a[i] << ", ";
    }
    cout << endl;
}

int main()
{
    int a[5] = {5, 3, 2, 4, 1};

    Sort(a, 5);            //自动调用,编译器根据a和5的类型来推导
    Println<int>(a, 5);    //显示调用,告诉编译器,调用的参数是int类型

    string s[5] = {"Java", "C++", "Pascal", "Ruby", "Basic"};

    Sort(s, 5);
    Println(s, 5); 

    return 0;
}

1,2,3,4,5,
Basic,C++, Java,Pascal,Ruby,

#include <iostream>

using namespace std;

template <typename T>       
void Swap(T& a, T& b)        
{
    T c = a;
    a = b;
    b = c;
}   

int main()
{
    void (*FPii)(int&,int&);  

    FPii = Swap ;                   //函数指针FPii

    void (*FPff)(float&,float&);

    FPff = Swap ;                  //函数指针FPff

    cout<<reinterpret_cast<void *>(FPii)<<endl;
    cout<<reinterpret_cast<void *>(FPff)<<endl;
   //cout<<reinterpret_cast<void *>(Swap)<<endl;
              //编译该行会出错,因为Swap()只是个模板,并不是一个真正函数
    return 0;
}

0x41ba98
0x41ba70

template <typename T1,typename T2,typename T3>       
T1 Add(T2 a,T3 b)
{
    return static_cast<T1>(a+b);      
}

#include <iostream>

using namespace std;

template<typename T1,typename T2,typename T3>       
T1 Add(T2 a,T3 b)
{
       return static_cast<T1>(a+b);      
}

int main()
{
       // int a = add(1,1.5);       //该行编译出错,没有指定返回值类型

       int a = Add<int>(1,1.5);
       cout<<a<<endl;                  //2

       float b = Add<float,int,float>(1,1.5);
       cout<<b<<endl;                  //2.5

       return 0;
}

2
2.5

#include <iostream>
  
using namespace std; 

template <typename T>        
T Max(T a,T b)
{
    cout<<"T Max(T a,T b)"<<endl;   
    return a > b ? a : b;
} 

template <typename T>        
T Max(T* a,T* b)                    //重载函数模板 
{
    cout<<"T Max(T* a,T* b)"<<endl;    
    return *a > *b ? *a : *b;
} 


int Max(int a,int b)                //重载普通函数 
{
    cout<<"int Max(int a,int b)"<<endl;   
    return a > b ? a : b;
}  
 
int main()
{  
    int a=0;
    int b=1;
    
    cout<<"a:b="<<Max(a,b) <<endl ;        //调用普通函数 Max(int,int)
    
    cout<<"a:b="<<Max<>(a,b)<<endl;        //通过模板参数表 调用 函数模板 Max(int,int)
    
    cout<<"1.5:2.0="<<Max(1.5,2.0)<<endl;   
     //由于两个参数默认都是double,所以无法隐式转换,则调用函数模板 Max(double,double)
    
    int *p1 = new int(1);
    int *p2 = new int(2); 
 
    cout<<"*p1:*p2="<<Max(p1,p2)<<endl;  // 调用重载函数模板 Max(int* ,int* )    
    
    cout<<"'a',100="<< Max('a',100)<<endl;        
    //将char类型进行隐式转换,从而调用普通函数 Max(int,int)
    
    
    delete p1;
    delete p2; 
    
    return 0;
}

int Max(int a,int b)
a:b=1

T Max(T a,T b)
a:b=1
 
T Max(T a,T b)
1.5:2.0=2

T Max(T* a,T* b)
*p1:*p2=2

int Max(int a,int b)
'a',100=100