模板 - 码农教程

1.冒泡排序

代码：

void Sort(int* arr,int nLength)                    
{                    
    int i;                
    int k;                
    for(i=0;i<nLength-1;i++)                
    {                
        for(k=0;k<nLength-1-i;k++)            
        {            
            if(arr[k]>arr[k+1])        
            {        
                int temp = arr[k];    
                arr[k] = arr[k+1];    
                arr[k+1] = temp;    
            }        
        }            
    }                
}

最简单的排序，不多做说明；

有个缺点：

需要排序的可能还有其它类型，比如double、float、short、结构、类等，不限于int；

这样导致需要给每一种类型都写一个相同的排序方法；

2.折半查找

代码：

int Find(int* arr,int nLength,int nElement)                        
{                        
    int nBegin = 0,nEnd = nLength-1,nIndex;                    
    while(nBegin<=nEnd)                    
    {                    
        nIndex = (nBegin+nEnd)/2;//(nBegin+nEnd)>>1                
        if(nElement > arr[nIndex])                
        {                
            nBegin = nIndex+1;            
        }                
        else if(nElement < arr[nIndex])                
        {                
            nEnd = nIndex-1;            
        }                
        else                
        {                
            return nIndex;            
        }                
    }                    
    return -1;                    
}

查找就是从一堆数据中找到自己需要的数据；

查找有两类：

顺序查找 ->从头开始一个个找，适合于没排序时查找；

例如：从一个数组｛1，5，3，7，9｝中找3的下标；从第一个数开始往后找，找到3后返回3的下标即可；

折半查找 ->前提条件是排好序，每次查找砍掉一半，可以提高查找效率；

例如：从数组{1,3,5,7,9,11,13}中找出3的下标；

用数组长度/2得到下标；7/2=3；

找到下标处的数与目标数比较；第3个数是5，5>3说明3在5前面，于是5和它后面的部分不再考虑；依次类推找到目标数；

3.模板

例如：上面的冒泡排序和折半查找只能适用于int型；

如果想适应于多种类型，可以使用模板；

模板的本质就是代码的复制；

编译时编译器将会模板替换成对应的类型；

使用模板和不使用模板的反汇编完全一样；

可以利用模板来实现链表结构；

函数中的类型不确定时可以用模板

例如：用模板修改后的冒泡排序和折半查找

template<class T>                
void Sort(T arr,int nLength)                
{                
    int i;            
    int k;            
    for(i=0;i<nLength-1;i++)            
    {            
        for(k=0;k<nLength-1-i;k++)        
        {        
            if(arr[k]>arr[k+1])    
            {    
                int temp = arr[k];
                arr[k] = arr[k+1];
                arr[k+1] = temp;
            }    
        }        
    }            
}                
template<class T>                
void Print(T arr,int nLength)                
{                
    int i;            
    for(i=0;i<nLength;i++)            
    {            
        printf("%d\n",arr[i]);        
    }            
}                
template<class T,class E>                
int Find(T arr,int nLength,E nElement)                
{                
    int nBegin = 0,nEnd = nLength-1,nIndex;            
    while(nBegin<=nEnd)            
    {            
        nIndex = (nBegin+nEnd)/2;//(nBegin+nEnd)>>1        
        if(nElement > arr[nIndex])        
        {        
            nBegin = nIndex+1;    
        }        
        else if(nElement < arr[nIndex])        
        {        
            nEnd = nIndex-1;    
        }        
        else        
        {        
            return nIndex;    
        }        
    }            
    return -1;            
}                
int main(int argc, char* argv[])                
{                          
    char arr[] = {2,6,1,8,4,3};                      
    Sort(arr,6);                        
    Print(arr,6);                       
    printf("---------------\n");                       
    int x = Find(arr,6,1);            
                
    printf("%x\n",x);                                  
    return 0;            
}

也可以在结构体和类中使用模板：结构体中的类型不确定时可以用模板

template<class T,class M>                
struct Base                
{                
    T x;            
    T y;            
                
    M a;            
    M b;            
                
    T Max()            
    {            
        if(x>y)        
        {        
            return x;    
        }        
        else        
        {        
            return y;    
        }        
    }            
    M Min()            
    {            
        if(a<b)        
        {        
            return a;    
        }        
        else        
        {        
            return b;    
        }        
    }            
};                
int main(int argc, char* argv[])                
{                
    Base<int,char> base;            
    base.x = 10;            
    base.y = 20;            
    base.a = 1;            
    base.b = 2;            
                
    int x = base.Max();                        
    int y = base.Min();                        
    printf("%d %d\n",x,y);                      
    return 0;            
}

原文地址：https://www.cnblogs.com/ShiningArmor/p/11940217.html