C++之：模板元编程（二） 模板形参

一、模板形参概述

有三种类型的模板形参：类型形参，非类型形参和模板形参。

二、类型形参

2.1 、类型模板形参

类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){};其中T就是一个类型形参，类型形参的名字由用户自已确定。模板形参表示的是一个未知的类型。模板类型形参可作为类型说明符用在模板中的任何地方，与内置类型说明符或类类型说明符的使用方式完全相同，即可以用于指定返回类型，变量声明等。

2.2、 不能为同一个模板类型形参指定两种不同的类型

比如：

template<class T>void h(T a, T b){}，语句调用h(2, 3.2)将出错，因为该语句给同一模板形参T指定了两种类型，第一个实参2把模板形参T指定为int，而第二个实参3.2把模板形参指定为double，两种类型的形参不一致，会出错。（针对函数模板）

注意：上面的结论针对函数模板是正确的，但是不适用于类模板。下面将对类模板的情况进行补充。

当我们声明类对象为：A<int> a，比如template<class T>T g(T a, T b){}，语句调用a.g(2, 3.2)在编译时不会出错，但会有警告，因为在声明类对象的时候已经将T转换为int类型，而第二个实参3.2把模板形参指定为double，在运行时，会对3.2进行强制类型转换为3。当我们声明类的对象为：A<double> a,此时就不会有上述的警告，因为从int到double是自动类型转换。

验证代码如下：

//TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX
#define TEMPLATE_DEMO_HXX

template<class T> class A{
    public:
        T g(T a,T b);
        A();
};

#endif

//TemplateDemo.cpp

#include<iostream.h>
#include "TemplateDemo.h"

template<class T> A<T>::A(){}

template<class T> T A<T>::g(T a,T b){
    return a+b;
}

void main(){
    A<int> a;
    cout<<a.g(2,3.2)<<endl;
}

编译结果：

warning C4244: “参数”: 从“double”转换到“int”，可能丢失数据

三、非类型形参

（1）模板的非类型形参

模板的非类型形参也就是内置类型形参，如template<class T, int a> class B{};其中int a就是非类型的模板形参。

（2）非类型形参在模板定义的内部是常量值，也就是说非类型形参在模板的内部是常量。

（3）模板的非类型形参只能是整型，指针和引用

像double，String, String **这样的类型是不允许的。但是double &，double *，对象的引用或指针是正确的。

（4）调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。

（5）注意：任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。

（6） 全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。

（7）sizeof表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。

（8）当模板的形参是整型时调用该模板时的实参必须是整型的，且在编译期间是常量，比如template <class T, int a> class A{};如果有int b，这时A<int, b> m;将出错，因为b不是常量，如果const int b，这时A<int, b> m;就是正确的，因为这时b是常量。

（9）非类型形参一般不应用于函数模板中，比如有函数模板template<class T, int a> void h(T b){}，若使用h(2)调用会出现无法为非类型形参a推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用h<int, 3>(2)这样就把非类型形参a设置为整数3。显示模板实参在后面介绍。

（10） 非类型模板形参的形参和实参间所允许的转换

a、允许从数组到指针，从函数到指针的转换。如：template <int *a> class A{}; int b[1]; A<b> m;即数组到指针的转换

b、const修饰符的转换。如：template<const int *a> class A{}; int b; A<&b> m; 即从int *到const int *的转换。

c、提升转换。如：template<int a> class A{}; const short b=2; A<b> m; 即从short到int 的提升转换

d、整值转换。如：template<unsigned int a> class A{}; A<3> m; 即从int 到unsigned int的转换。

e、常规转换。

实例：

//由用户自己亲自指定栈的大小，并实现栈的相关操作
//TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX
#define TEMPLATE_DEMO_HXX

template<class T,int MAXSIZE> class Stack{//MAXSIZE由用户创建对象时自行设置
    private:
        T elems[MAXSIZE];    // 包含元素的数组
        int numElems;    // 元素的当前总个数
    public:
        Stack();    //构造函数
        void push(T const&);    //压入元素
        void pop();        //弹出元素
        T top() const;    //返回栈顶元素
        bool empty() const{     // 返回栈是否为空
            return numElems == 0;
        }
        bool full() const{    // 返回栈是否已满
            return numElems == MAXSIZE;
        }
};

template <class T,int MAXSIZE> 
Stack<T,MAXSIZE>::Stack():numElems(0){     // 初始时栈不含元素
    // 不做任何事情
}

template <class 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<class T,int MAXSIZE>
void Stack<T,MAXSIZE>::pop(){
    if (numElems <= 0) {
        throw std::out_of_range("Stack<>::pop(): empty stack");
    }
    --numElems;               // 减少元素的个数
}

template <class T,int MAXSIZE>
T Stack<T,MAXSIZE>::top()const{
    if (numElems <= 0) {
        throw std::out_of_range("Stack<>::top(): empty stack");
    }
    return elems[numElems-1];  // 返回最后一个元素
}

#endif

//TemplateDemo.cpp

#include<iostream.h>
#include <iostream>
#include <string>
#include <cstdlib>
#include "TemplateDemo.h"

int main(){
    try {
        Stack<int,20>  int20Stack;  // 可以存储20个int元素的栈
        Stack<int,40>  int40Stack;  // 可以存储40个int元素的栈
        Stack<std::string,40> stringStack; // 可存储40个string元素的栈

        // 使用可存储20个int元素的栈
        int20Stack.push(7);
        std::cout << int20Stack.top() << std::endl;    //7
        int20Stack.pop();

        // 使用可存储40个string的栈
        stringStack.push("hello");
        std::cout << stringStack.top() << std::endl;    //hello
        stringStack.pop();    
        stringStack.pop();    //Exception: Stack<>::pop<>: empty stack
        return 0;
    }
    catch (std::exception const& ex) {
        std::cerr << "Exception: " << ex.what() << std::endl;
        return EXIT_FAILURE;  // 退出程序且有ERROR标记
    }
}

---

参考资料

[1] http://www.cnblogs.com/gw811/archive/2012/10/25/2738929.html