C++模板编程

函数模板和类模板

函数模板

函数同名问题

当一般函数与函数模板同名时，编译器不会报错（函数模板只有在类型T确定之后才会生成对应的函数体，否则它仅仅只是模板。）。当出现函数调用时，优先匹配一般函数。

double Max(double a,double b)                 //一般函数

{

         returna>b?a:b;

}

 

template<typename T>                     //函数模板

T Max(T a,T b)

{

         returna>b?a:b;

}

 

注意：在上例中，当只有函数模板时，函数调用时如果两个参数类型不一致时（如：Max(12.5, 5)），编译出错。如果在函数调用时指定模板类型（如：Max<int>(12.5, 5)），将会进行类型强转,则不会报错；如有一般函数，函数调用时如果两个参数类型不一致时（如：Max(12.5, 5)），将自动进行类型强转，调用一般函数。

如：

Max(12.5,8);//没有一般函数，编译出错；有一般函数，调用一般函数

Max<int>(12.5,8);//不论有没有一般函数，都调用模板函数

 

注意：如果在函数调用时指定模板类型（如：Max<int>(12.5, 5)），将会进行类型强转，但是强转的形参类型不能是引用，否则编译出错。如Max<int>(12.5, 5)会将12.5强转为12，函数模板的第一个参数就不能是引用类型，但是第二个参数则可以是引用类型。

引用问题

template<typenameT>

T* Max(T&a,T& b)

{

    return a<b ? &b : &a;

}

在上例中：当引用作为函数参数，传递数组时，数组长度必须相同否则编译出错。如果是值传递的话则不会出现问题。因为值传递传递的是指针，而引用则是引用了整个数组，相当于参数是数组引用，如果数组长度不一致的话，编译器将a和b解释成两种类型，而模板中是相同类型，编译出错。

函数模板的声明和模板函数的生成

1.函数模板的声明和模板函数的生成

 1.1函数模板的声明

        函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。

 

函数模板的声明形式为：

template<typename 数据类型参数标识符>

返回类型函数名(参数表)

{

    函数体

}

 

        其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或class)是声明数据类型参数标识符的关键字，用以说明它后面的标识符是数据类型标识符。这样，在之后定义的这个函数中，凡希望根据实参数据类型来确定数据类型的变量，都可以用数据类型参数标识符来说明，从而使这个变量可以适应不同的数据类型。例如：

template<typename T>

T fuc(T x, int y)

{

    Tx;

   //……

}

 

如果主调函数中有以下语句：

double d;

int a;

fuc(d,a);

 

则系统将用实参d的数据类型double去代替函数模板中的T生成函数：

double fuc(double x,int y)

{

   double x;

   //……

}

 

        函数模板只是声明了一个函数的描述即模板，不是一个可以直接执行的函数，只有根据实际情况用实参的数据类型代替类型参数标识符之后，才能产生真正的函数。

关键字typename也可以使用关键字class，这时数据类型参数标识符就可以使用所有的C++数据类型。

 

1.2.模板函数的生成

 

        函数模板的数据类型参数标识符实际上是一个类型形参，在使用函数模板时，要将这个形参实例化为确定的数据类型。将类型形参实例化的参数称为模板实参，用模板实参实例化的函数称为模板函数。模板函数的生成就是将函数模板的类型形参实例化的过程。例如：

使用中应注意的几个问题：

 

⑴函数模板允许使用多个类型参数，但在template定义部分的每个形参前必须有关键字typename或class，即：

template<class 数据类型参数标识符1，…，class 数据类型参数标识符n>

返回类型函数名(参数表)

{

     函数体

}

 

⑵在template语句与函数模板定义语句<返回类型>之间不允许有别的语句。如下面的声明是错误的：

template<class T>

int I;

T min(T x,T y)

{

   函数体

}

 

⑶模板函数类似于重载函数，但两者有很大区别：函数重载时，每个函数体内可以执行不同的动作，但同一个函数模板实例化后的模板函数都必须执行相同的动作

 

2 函数模板的异常处理

       函数模板中的模板形参可实例化为各种类型，但当实例化模板形参的各模板实参之间不完全一致时，就可能发生错误，如：

template<typename T>      

T min(T &x, T &y)

{ return (x<y)?x:y;  }

 

void func(int i, char j)

{

  min(i, i);

  min(j, j);

  min(i, j);

  min(j, i);

}

 

        例子中的后两个调用是错误的，出现错误的原因是，在调用时，编译器按最先遇到的实参的类型隐含地生成一个模板函数，并用它对所有模板函数进行一致性检查，例如对语句

 

min(i, j)；

 

        先遇到的实参i是整型的，编译器就将模板形参解释为整型，此后出现的模板实参j不能解释为整型而产生错误，此时没有隐含的类型转换功能。解决此种异常的方法有两种：

 

⑴采用强制类型转换，如将语句min(i, j);改写为min(i,int( j));

 

⑵用非模板函数重载函数模板

方法有两种：

①借用函数模板的函数体

此时只声明非模板函数的原型，它的函数体借用函数模板的函数体。如改写上面的例子如下：

 

template<typename T>      

T min(T &x, T &y)

{ return (x<y)?x:y;  }

 

int min(int,int);

 

void func(int i, char j)

{

  min(i, i);

  min(j, j);

  min(i, j);

  min(j, i);

}

 

执行该程序就不会出错了，因为重载函数支持数据间的隐式类型转换。

此方法在VC 6.0、Visual studio 2005——Visualstudio 2013环境下，四个调用编译都不通过。前两种必须显示使用模板（如min<int>(i, i);），如果是隐式的话，编译器先推测到函数声明，但函数声明没有函数体，编译报错，而显示使用模板则会根据参数实例化生成函数体。移植性太差，不建议使用。

 

②重新定义函数体

就像一般的重载函数一样，重新定义一个完整的非模板函数，它所带的参数可以随意。C++中，函数模板与同名的非模板函数重载时，应遵循下列调用原则：

 

1: 寻找一个参数完全匹配的函数，若找到就调用它。若参数完全匹配的函数多于一个，则这个调用是一个错误的调用。

 

2: 寻找一个函数模板，若找到就将其实例化生成一个匹配的模板函数并调用它。

 

3: 若上面两条都失败，则使用函数重载的方法，通过类型转换产生参数匹配，若找到就调用它。

 

4:若上面三条都失败，还没有找都匹配的函数，则这个调用是一个错误的调用。

类模板

同名类模板冲突

如果定义有一般类，定义同名模板类时，产生编译错误

例如：

class Point                 //定义一般类

{

         ……

};

 

template<class T>

class Point                 //定义模板类

{

         ……                   //编译出错

};

类模板的静态成员变量

       如果类模板中的静态成员变量有特定类型的初始化，那么凡是类型与该特定类型相同的实例化的模板类对象，都将使用该默认值初始化静态成员变量。

例如：

/*template<class T1, class T2>

class Rect

{

public:

         staticT1 nCount;//静态变量

};

 

//万能初始化

template<class T1,class T2>

T1 Rect<T1,T2>::nCount = 1;

 

//特定类型初始化

template<>

int Rect<int,int>::nCount = 15;*/

 

Rect<int,int> rc1(10,10,100,100);                     //模板类类型与特定类型相同

Rect<float,float> rc2(10,10,100,100);           //模板类类型与特定类型不相同

cout << rc1.nCount << endl;             //15    通过模板类对象访问

cout << Rect<int,int>::nCount<< endl;            //15           通过模板类名访问

cout << rc2.nCount << endl;             //1     通过模板类对象访问

cout << Rect<float,float>::nCount<< endl;              //1             通过模板类名访问

typename和class的区别

       实际上可以说没有区别。按 C++ 标准来说，template<typename T> 用于基础数据类型，typename 指类型名，T 可以取 char、int、double 等。template<class T> 用于类，T 可以取任何类。但是这里有一个问题，结构体应该用 typename 还是 class? 结构体肯定不是基础数据类型，但也不是类。答案是 typename 和 class 都可以。所以实际情况是，template<class T> 的 T 也可以取基础数据类型；tempate<typenameT> 的 T 也可以取类。但有一个特例，就是当 T 是一个类，而这个类又有内嵌类(假设名为 innerClass) 时或在这个类中用typedef定义的新类型(假设名为MyType)时，应该用 template<typename T>:

typename T::innerClass  myInnerObject;

        这里的 typename 告诉编译器，T::innerClass 是一个类型名，程序要声明一个 T::innerClass 类的对象，而不是声明 T 的静态成员，而 typename 如果换成 class 则语法错误

例如：

template<typenameT>

classMyTestClass

{

public:

    //这里的typename是用于通知编译器，其后的MyType是模板T定义的内部类型，从这个代码示例

    //中可以看出，不管是在函数参数、返回值还是定义成员变量，都要遵守这一语法规则。

    MyTestClass(typenameT::MyTypep) : _p(p), M(typenameT::innerClass())

    {

    }

 

    typename T::MyType GetData()const

    {

        return _p;

    }

   

protected:

    typename T::MyType _p;

    typename T::innerClass M;

};

 

classParamClass

{

public:

    typedef char* MyType;       //内部类型

    class innerClass            //内嵌类

    {

    public:

        innerClass()

        {

        }

 

        ~innerClass()

        {

        }

    };

};

 

#if 1

int main()

{

    MyTestClass<ParamClass> t("Hello");     //T为ParamClass

    printf("The data is %s.\n", t.GetData());       //输出The data is Hello.

    return 0;

}

#endif

 

注意：在高版本的编译器（如visual studio 2013）中，可以在类类型前使用class，但是在非类类型前必须使用typename。

如：定义模板template<class T>或template<typenameT>

 

classT::MyType _p;//Error

typenameT::MyType _p;//OK

classT::innerClass M;//OK

模板的实例化

编译器根据函数模板生成具体的函数，或根据类模板生成具体的类的过程叫做模板的实例化。

隐含实例化

vector<int> vArray(10, 2);//实例化

        在程序中，只会为int类型实例化向量模板(vector)，不会为bool、float等实例化模板，因为它们从未被调用过。这种自动按需进行的模板实例化，叫做隐含实例化。

          对一个类模板进行实例化时，只有它的成员的声明会被实例化。而对类模板成员函数定义的实例化也是按需进行的，只有一个函数会被使用时，它才会被实例化。类的静态数据成员的定义的实例化，同样是按需进行的。

显示实例化

隐式实例化是按需自动进行的，而显示实例化是由专门的代码指定的。

显示实例化的一般语法形式：

template 实例化目标的声明;

例如：

template<typenameT>        //函数模板

void Print(T&value,const char *delimiter)

{

    cout <<value << delimiter << endl;

}

 

template<classT>       //类模板

classPoint

{

public:

    Point(Tx, T y) :X(x), Y(y)

    {

 

    }

 

    const T& GetX() const

    {

        return X;

    }

 

    const T& GetY() const

    {

        return Y;

    }

private:

    T X;

    T Y;

};

 

templatevoid Print<int>(int& value,constchar *delimiter);//显示实例化函数模板

template Point<int>;        //显示实例化类模板

注意：对类模板进行显示实例化的同时，类模板的成员函数和静态数据成员的定义也会被实例化。

       有了显示实例化的工具，就可以在一定程度上将会被其他源文件使用的函数模板、类模板成员函数或数据成员的定义放在源文件中。办法是在该源文件中对模板进行显示实例化，这样尽管该源文件没有对模板实例的需求，但目标文件中仍然会生成相关的代码，从而允许被其他源文件所生成的目标代码引用。然而，这样做也是有前提的，就是在编译模板的时候，能够穷举模板的哪些实例会被其他函数实例化。

为模板定义特殊的实现

模板的特化

       C++允许程序员为一个函数模板或类模板在某些特定参数下提供特殊的定义，这就是模板的特化。“template<>”是进行特化时所需的固定格式。

注意：被特化的函数模板、类模板中被特化的成员函数和静态数据成员，以及被特化的类模板的成员函数和静态数据成员，像非模板的成员函数和静态数据成员那样，无论是否被使用，相关的目标代码都会被生成，因此它们的定义应当放在源文件中，而非头文件中。

类模板的偏特化

        C++允许在一部分模板参数固定而另一部分模板参数可变的情况下规定类模板的特殊实现，这种行为叫做类模板的偏特化。偏特化只是针对类模板，函数模板不支持偏特化。

        偏特化与特化的不同之处在于，特化将所有的模板参数都固定下来了，因而对类模板、函数模板特化的结果不再是模板，而是具有普通类、普通函数的性质，但偏特化由于仍然保留了一部分未定的参数，使得偏特化的结果仍然是模板。

一个类可以定义多个偏特化版本，实例化时，最特殊的那一个总会被选中。

函数模板的重载

C++不允许将函数模板偏特化，但函数模板像普通函数那样允许被重载。

友元模板  

        当模板函数或模板类作为其他类(可以是模板类)的友元的时候，必须将模板定义template<class T……>也要写在对应的友元声明前面。

template<classT>

classPoint

{

public:

    Point(T x,T y);

    Point(constPoint& ref);

    virtual ~Point();

 

    bool operator <(constPoint& ref);

 

    template<classT>//不能省略

    friend void show(constT& ref);//友元模板函数

 

    template<classT>//不能省略

    friend class Test;//友元模板类

private:

    T X;

    T Y;

};

模板和泛型编程

1:什么是泛型编程

       所谓泛型编程就是以独立于任何特定数据类型的方式编写代码。使用泛型程序时，我们需要提供具体程序实例所操作的类型和值。

  标准库中的容器，迭代器和算法都是泛型编程的例子。

 

2：模板和泛型的关系？

     模板是泛型编程的基础，使用模板时无需考虑模板的定义，模板是创建类的或函数的蓝图或公式。

 

非类型模板参数

1. 非类型的类模板参数。
2. 非类型的函数模板参数。
3. 非类型模板参数的限制。

        模板的参数应该是类型。需要通过指定某种类型来实例化一个模板。但是，在这里，会看见一些值作为模板参数的情况。这里着重强调类型和值的区别。正因为是值作为模板参数，这一章才显得很特别。

 

一：非类型的类模板参数

       定义一个Stack模板，要求使用一个固定大小的数组作为元素的容器，并且数组的大小可以由模板的使用者自己定义。那么，对于模板的设计者，就应该提供一个接口使得使用者可以定义数组的大小。这就需要用到非类型的类模板参数。下面的代码能很好的解释这个问题：

 

#include <iostream>

 #include <string>

 #include <cstdlib>

 #include <stdexcept>

 

 template<typename T, int MAXSIZE>

 class Stack{

     private:

         T elems[MAXSIZE];

        int numElems;

 

    public:

        Stack();

        void push(T const&);

        void pop();

        T top() const;

        bool isEmpty() const{

            return numElems == 0;

        }

 

        bool isFull() const{

            return numElems == MAXSIZE;

        }

};

 

template<typename T, int MAXSIZE>

Stack<T, MAXSIZE>::Stack():numElems(0)

{

    // 不作任何事，仅为了初始化numElems。

}

 

template<typename T, int MAXSIZE>

void Stack<T, MAXSIZE>::push(T const& elem)

{

    if(numElems == MAXSIZE)

    {

        throw std::out_of_range("Stack<>::push()==>stack is full.");

    }

    

    elems[numElems] = elem;

    ++numElems;

}

 

template<typename T, int MAXSIZE>

void Stack<T, MAXSIZE>::pop()

{

    if(numElems <= 0)

    {

        throw std::out_of_range("Stack<>::pop: empty stack");

     }

 

     --numElems;

 }

 

 template<typename T, int MAXSIZE>

 T Stack<T, MAXSIZE>::top()const

 {

     if(isEmpty())

     {

         throw std::out_of_range("Stack<>::pop: empty stack");

     }

 

     // 返回最后一个元素。

    return elems[numElems - 1];

}

 

int main()

{

    try

    {

        Stack<int, 20> int20Stack;

        Stack<int, 40> int40Stack;

        Stack<std::string, 40> stringStack;

 

        int20Stack.push(7);

        std::cout<<"int20Stack.top() : "<<int20Stack.top()<<std::endl;

        int20Stack.pop();

 

        stringStack.push("HelloWorld!");

       std::cout<<"stringStack.top() : "<<stringStack.top()<<std::endl;

       stringStack.pop();

       stringStack.pop();

   }

   catch(std::exception const& ex)

   {

       std::cerr<<"Exception: "<<ex.what()<<std::endl;

 

       return EXIT_FAILURE;

    }

 

    return 0;

}

 

上面的代码揭示了非类型的类模板参数的定义和使用方法。需要注意的有：

1. 非类型的类模板参数也是模板的参数之一。有某个非类型的模板参数的模板和没有那个非类型的模板参数的模板是两个不同的模板。
2. 上面的int20Stack实例和int40Stack实例中，虽然实例化模板的时候都使用了int作为类型参数。但是他们仍然是两个不同的类的实例。他们之间没有任何的关系。不能相互进行类型转化，也不能赋值。这里需要注意，类模板的实例化在实质上是编译器将原来的模板拷贝一份，然后根据实例化参数替换原来的类型定义（也包括非类型的模板参数），从而成为一个新的类。也就是说，对于相同的实例化参数（包括非类型的模板参数）编译器都会实例化成为一个相同的类，只是我们不知道类名罢了。从这个角度上来说，上面的int20Stack和int40Stack是两个不同类的两个实例，他们之间没有任何关系，因为他们的模板实例化参数不一样。但是，如果定义为［Stack<int, 20> intStack1; Stack<int, 20> intStack2;］那么intStack1和intStack2可以相互赋值。因为他们对模板的实例化参数是一样的，从而都是同一类型的。这里有必要澄清一个事实，如果两个类有相同的成员函数和成员变量，他们生成的实例仍然是两个类型，与这里的情况完全不一样。
3. 非类型的类模板参数也可以有缺省值。例如，template<typename T, int MAXSIZE ＝ 100>

强调一下，非类型的模板参数和类型模板参数一样，也是标识一个模板的因素之一。

 

二：非类型的函数模板参数

函数模板的非类型参数主要用来为函数提供一个运算常量。关于非类型的函数模板参数，书中有下面的例子：

 //函数模板定义

  template<typename T, int VAL>

  T addValue(T const& x)

  {

      return x + VAL;

  }

  

  //其他代码

  

 

//函数模板的使用

std::transform(source.begin(), source.end(), dest.begin(),

            (int(*) (int const&))addValue<int, 5>);

 

        上面的代码中定义了一个函数模板，目的是对传入的参数加上一个指定的int型的5。这样的函数被普遍的使用在对一组数据进行同一处理的场合。例如，12行。这里需要注意的是：一std::transform函数本身就是一个模板函数，它的最后一个参数可以传递一个函数指针。因此，(int(*) (int const&))addValue<int, 5>其实是一个指向实例化后的addValue<T, int VAL>模板函数的指针。至于这个指针怎么读，还请高手指教。另外需要注意的一点是，std::transform的最后一个参数不一定要是模板函数，任何函数都可以（关于std::transform的正确理解参考下面的评论）。只是模板函数更合适处理多种类型的数据罢了。

注意：不要函数指针{(int(*) (int const&))}类型转换也能正常工作。如：

//函数模板的使用

std::transform(source.begin(), source.end(), dest.begin(),addValue<int, 5>);

 

三：非类型模板参数的限制

        关于非类型模板参数的限制目前记住它可以是常整型（包括枚举类型）和指向外部连接对象的指针就可以了。由于历史原因，浮点型不能作为非类型模板的参数；而指针和字符串作为非类型模板的参数是有条件的。我想这与变量的作用范围和生命周期有关吧。

C++编译器编译模板类的过程

前言

　　常遇到询问使用模板到底是否容易的问题，我的回答是：“模板的使用是容易的，但组织编写却不容易”。看看我们几乎每天都能遇到的模板类吧，如STL, ATL, WTL, 以及Boost的模板类，都能体会到这样的滋味：接口简单，操作复杂。

      本文对象是那些熟悉模板但还没有很多编写模板经验的程序员。本文只涉及模板类，未涉及模板函数。但论述的原则对于二者是一样的。

 

　　问题的产生

　　通过下例来说明问题。例如在array.h文件中有模板类array：

　　// array.h

　　template <typename T, int SIZE>

　　class array

　　{

　　T data_[SIZE];

　　array (const array& other);

const array&operator = (const array& other);

 

　　public:

　　array(){};

　　T& operator[](int i) {return data_[i];}

　　const T& get_elem (int i) const {return data_[i];}

　　void set_elem(int i, const T& value) {data_[i] = value;}

　　operator T*() {return data_;}

　　};

 

　　然后在main.cpp文件中的主函数中使用上述模板：

 

　　// main.cpp

　　#include "array.h"

　　int main(void)

　　{

　　array<int, 50> intArray;

　　intArray.set_elem(0, 2);

　　int firstElem = intArray.get_elem(0);

　　int* begin = intArray;

　　}

 

　　这时编译和运行都是正常的。程序先创建一个含有50个整数的数组，然后设置数组的第一个元素值为2，再读取第一个元素值，最后将指针指向数组起点。

 

　　但如果用传统编程方式来编写会发生什么事呢？我们来看看：

 

　　将array.h文件分裂成为array.h和array.cpp二个文件(main.cpp保持不变)

 

　　// array.h

　　template <typename T, int SIZE>

　　class array

　　{

　　T data_[SIZE];

　　array (const array& other);

　　const array& operator = (const array& other);

 

public:

 

　　array(){};

　　T& operator[](int i);

　　const T& get_elem (int i) const;

　　void set_elem(int i, const T& value);

　　operator T*();

　　};

 

　　// array.cpp

　　#include "array.h"

　　template<typename T, int SIZE> T& array<T,SIZE>::operator [](int i)

　　{

　　         return data_[i];

　　}

 

　　template<typename T, int SIZE> const T& array<T,SIZE>::get_elem(int i) const

　　{

　　         return data_[i];

　　}

 

　　template<typename T, int SIZE> void array<T,SIZE>::set_elem(int i, const T& value)

　　{

　　         data_[i] = value;

　　}

 

　　template<typename T, int SIZE> array<T, SIZE>::operatorT*()

　　{

　　         return data_;

　　}

 

　　编译时会出现3个错误。问题出来了：

　　为什么错误都出现在第一个地方？

　　为什么只有3个链接出错？array.cpp中有4个成员函数。

 

　　要回答上面的问题，就要深入了解模板的实例化过程。

　　模板实例化

　　程序员在使用模板类时最常犯的错误是将模板类视为某种数据类型。所谓类型参量化(parameterized types)这样的术语导致了这种误解。模板当然不是数据类型，模板就是模板，恰如其名：

　　编译器使用模板，通过更换模板参数来创建数据类型。这个过程就是模板实例化(Instantiation)。从模板类创建得到的类型称之为特例(specialization)。模板实例化取决于编译器能够找到可用代码来创建特例(称之为实例化要素，point of instantiation)。要创建特例，编译器不但要看到模板的声明，还要看到模板的定义。模板实例化过程是迟钝的，即只能用函数的定义来实现实例化。

　　再回头看上面的例子，可以知道array是一个模板，array<int, 50>是一个模板实例—— 一个类型。从array创建array<int,50>的过程就是实例化过程。实例化要素体现在main.cpp文件中。如果按照传统方式，编译器在array.h文件中看到了模板的声明，但没有模板的定义，这样编译器就不能创建类型array<int, 50>。但这时并不出错，因为编译器认为模板定义在其它文件中，就把问题留给链接程序处理。

 

　　现在，编译array.cpp时会发生什么问题呢？编译器可以解析模板定义并检查语法，但不能生成成员函数的代码。它无法生成代码，因为要生成代码，需要知道模板参数，即需要一个类型，而不是模板本身。这样，链接程序在main.cpp 或 array.cpp中都找不到array<int, 50>的定义，于是报出无定义成员的错误。

　　至此，我们回答了第一个问题。但还有第二个问题，在array.cpp中有4个成员函数，链接器为什么只报了3个错误？回答是：实例化的惰性导致这种现象。在main.cpp中还没有用上operator[]，编译器还没有实例化它的定义。

 

　　解决方法

　　认识了问题，就能够解决问题：

　　①在使用类模板的源文件中包含类模板的声明文件和定义文件

　　②用另外的文件来显式地实例化类型，这样链接器就能看到该类型。

       ③使用export关键字。（此方法，不建议使用，移植性差）

 

　　前二种方法通常称为包含模式，第三种方法则称为分离模式。

　　第一种方法意味着在使用模板的转换文件中不但要包含模板声明文件，还要包含模板定义文件。在上例中，就是第一个示例，在array.h中定义所有的成员函数。或者在main.cpp文件中也包含进array.cpp文件。这样编译器就能看到模板的声明和定义，并由此生成array<int, 50>实例。这样做的缺点是编译文件会变得很大，显然要降低编译和链接速度。

 

　　第二种方法，通过显式的模板实例化得到类型。最好将所有的显式实例化过程安放在另外的文件中。在本例中，可以创建一个新文件templateinstantiations.cpp：

　　// templateinstantiations.cpp

　　#include "array.cpp"

template [class]array <int, 50>; // 显式实例化(class 可以省略)

 

　　array<int, 50>类型不是在main.cpp中产生，而是在templateinstantiations.cpp中产生。在使用到类模板的源文件中只需包含类模板声明文件即可，这样链接器就能够找到它的定义。用这种方法，不会产生巨大的头文件，加快编译速度。而且头文件本身也显得更加“干净”和更具有可读性。但这个方法不能得到惰性实例化的好处，即它将显式地生成所有的成员函数。另外还要维护templateinstantiations.cpp文件。

 

　　第三种方法是在模板定义中使用export关键字，剩下的事就让编译器去自行处理了。当我在Stroustrup的书中读到export时，感到非常兴奋。但很快就发现VC 6.0不支持它，后来又发现根本没有编译器能够支持这个关键字(第一个支持它的编译器要在2002年底才问世)。自那以后，我阅读了不少关于export的文章，了解到它几乎不能解决用包含模式能够解决的问题。欲知更多的export关键字，建议读读Herb Sutter撰写的文章。

　　结论

       要开发模板库，就要知道模板类不是所谓的"原始类型"，要用其它的编程思路。本文目的不是要吓唬那些想进行模板编程的程序员。恰恰相反，是要提醒他们避免犯下开始模板编程时都会出现的错误。

模板元编程

模板元编程是指在模板实例化的同时利用编译器完成一些计算工作。

 

程序实例1：计算n的阶乘

template<int N>

structfactorial        //主模板

{

    //枚举元素的值在编译时确定，计算在编译期间，而不是在运行时

    //枚举元素可以当作静态常量，可以通过“类名::枚举元素名”直接访问枚举元素

    enum{ result = N*factorial<N - 1>::result };

};

 

template<>

structfactorial<1>     //完全特化

{

    enum{ result = 1 };

};

 

cout<< factorial<5>::result << endl;//通过类名直接访问匿名枚举变量元素 输出5！= 120

 

程序实例2：实现pow的功能

template<unsigned N>

//内联函数，在编译时进行替换

inlinedouble power(doublevalue)//主函数模板

{

    //递归调用

    return value*power<N - 1>(value);

}

 

template<>

inlinedouble power<1>(doublevalue)//函数模板的特化

{

    return value;

}

 

cout<< power<4>(3) << endl;    //输出3^4 = 81

 

程序实例3：实现pow功能，为模板引入类型参数T，比程序2更通用

template<unsigned N>

classPow       //主模板

{

public:

    //类模板中嵌套函数模板

    template<classT>  

    //定义为静态成员函数便于用类名直接调用，不用同具体的对象关联

    static T power(Tvalue)

    {

        //递归调用

        return value*Pow<N-1>::power(value);

    }

 

    enum A{ result = N*factorial<N - 1>::result };

};

 

template<>

classPow<1>    //偏特化类模板

{

public:

    template<classT>

    static T power(Tvalue)

    {

        return value;

    }

 

    enum A{ result = 1 };

};

 

//Pow<4>::power(2)的写法不是很方便，设定一个辅助函数

//在函数中执行Pow<4>::power(2)语句，并将结果返回

//这样就可以通过power<4>(2)来求2^4的值

template<unsigned N,classT>

inlineT power(Tvalue)

{

    return Pow<N>::power(value);

}

 

cout<< Pow<3>::result << endl; //通过类名直接访问枚举变量元素  输出3! = 6

cout<< Pow<4>::power(2)<< endl;//通过模板类直接调用，写法复杂  输出2^4 = 16

cout<< power<5>(2) << endl;   //通过辅助函数调用，写法简便     输出2^5 = 32

模板编程是泛型编程的一部分，都属于泛型程序设计范畴，若想进一步了解泛型程序设计，请观看博主“泛型程序设计与STL”这篇博文，相信你会在那里找到你想知道的东西，希望对你的学习有一个推动力，哈哈……