C++模板编程是泛型编程的实现方式，因为C++中的类型都是强类型。所以导致每个变量都有一种相应的类型。这样就会出现一个弊端，就是相同一个算法针对不同类型的參数，就要实现多个版本号，这样岂不是非常麻烦。

那么，C++中是否会有一种办法来帮助我们实现算法通用呢？答案是有的，这就是模板编程，模板编程的目的就是实现代码的高度复用。降低不必要的反复劳动，从而实现泛型编程的目标。

以下。我们通过详细的样例来帮助大家体会模板的优点。这样才会加深大家的印象。

例1 实现一个函数。找出整形数组中的最大值，并返回。

//求出整数数组中的最大值

//參数：

//pInput：数组

//nSize：数组大小

//nMax：返回数组中的最大值，是一个输出參数

//返回值：假设函数执行成功返回1，否则返回0。

#include<stdlib.h>
#include<stdio.h>

int max_int(int * pInput, int nLen, int & nMax)
{
    if(!pInput)
    {
        return 0;
    }
    nMax = pInput[0];
    int i = 0;
    for(i = 1; i < nLen; i++)
    {
        if(nMax < pInput[i])
        {
            nMax=pInput[i];
        }
    }
    return 1;
}

int main()
{
    int Array[5] = { 5, 6, 8, 9, 7 };
    int nMax = 0;
    if(max_int(Array, 5,nMax) == 0)
    {
        printf("计算失败!\n");
        return 0;
    }
    printf("最大值：%d\n", nMax);
    return 0;
} 

例1中的函数功能是查找整个整型数组中的最大值。执行效果例如以下：



可是。假设我们想要查找到一个浮点型数组的最大值。该怎样写呢？

例2 实现一个函数，找出浮点型数组中的最大值，并返回。

//求出浮点数组中的最大值

//參数：

//pInput：数组

//nSize：数组大小

//fMax：返回数组中的最大值，是一个输出參数

//返回值：假设函数执行成功返回1，否则返回0；

#include<stdlib.h>
#include<stdio.h>

int max_float(float * pInput, int nLen, float & fMax)
{
    if(!pInput)
    {
       return 0;
    }
    fMax = pInput[0];
    int i = 0;
    for (i = 1; i < nLen; i++)
    {
        if(fMax<pInput[i])
        {
            fMax = pInput[i];
        }
    }
    return 1;
}

int main()
{
    float Array[5] = { 5.1, 6.2, 8.6, 9.8, 7.5 };
    float fMax = 0;
    if(max_float(Array, 5, fMax) == 0)
    {
        printf("计算失败!\n");
        return 0;
    }
    printf("最大值：%.2ff\n", fMax);
    return 0;
}

例2中的函数实现了查找一个浮点数组中的最大值，执行效果例如以下：



如今，让我们来一起反思一下，假如。我们如今要再实现一个函数，来查找整个字符数组中的最大值，那么，我们是不是还要象上面一样继续实现一个函数，代码中的逻辑一样，可是參数类型不一样，例如以下

int max_char(char * pInput, int nLen, char & cMax)
{
    if(!pInput)
    {
        return 0;
    }
    cMax=pInput[0];
    int i = 0;
    for(i=1; i < nLen; i++)
    {
        if(cMax<pInput[i])
        {
            cMax=pInput[i];
        }
     }
     return 1;
}
 

相信有的读者看到这里一定会说“这样也太麻烦了，难道C++中就没有好的方法了吗？”，答案是“有”,那就是模板，就是我们上文中提到的一种泛型编程的实现机制。
以下。就让我们来一起看一下，假设使用模板，该怎样实现上面的算法，而且能够同一时候被整型，浮点型。字符型同一时候使用，例如以下：
例3 实现一个函数，找出数组中的最大值，并返回。数组的类型能够是整型。浮点型，字符型。

//求出数组中的最大值

//參数：

//pInput：数组

//nSize：数组大小

//Max：返回数组中的最大值，是一个输出參数

//返回值：假设函数执行成功返回1。否则返回0；

#include<stdlib.h>
#include<stdio.h>

template<typename T>
int max_array(T * pInput, int nLen, T & max)
{
    if (!pInput)
    {
        return 0;
    }
    max = pInput[0];
    int i = 0;
    for (i = 1; i < nLen; i++)
    {
        if (max < pInput[i])
        {
            max = pInput[i];
        }
    }
    return 1;	
}

int main()
{
    int nArray[5] = { 9, 5, 8, 6, 7 };
    double fArray[5] = { 5.1, 6.2, 8.6, 9.8, 7.5 };
    char cArray[5] = {‘a‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘};
    int nMax = 0;
    double lfMax = 0.0;
    char cMax = 0;

   if (max_array<int>(nArray, 5, nMax) == 0)
   {
       printf("计算失败!\n");
       return 0;
   }
   else
   {
       printf("整数数组中的最大值：%d\n", nMax);
   }

   if (max_array<double>(fArray, 5, lfMax) == 0)
   {
       printf("计算失败!\n");
       return 0;
   }
   else
   {
       printf("浮点数组中的最大值：%.2lf\n", lfMax);
   }

   if(max_array<char>(cArray, 5, cMax) == 0)
   {
       printf("计算失败!\n");
       return 0;
   }
   else
   {
       printf("字符数组中的最大值：%c\n", cMax);
   }
   return 0;
}
 

例3中定义了一个函数模板，然后分别被3个数组：整型数组，浮点数组，字符数组分别调用，执行效果例如以下：


今天。我们主要是通过几个小样例，帮助大家体会模板的优点。

模板的主要目标就是实现逻辑代码和数据类型相分离。从而实现代码的高度复用。