C++模板中的非类型参数

模板是一种泛型技术，目的是将数据的类型参数化，以增强 C++ 语言（强类型语言）的灵活性。C++ 对模板的支持非常自由，模板中除了可以包含类型参数，还可以包含非类型参数，例如：

template<typename T, int N> class Demo{ };
template<class T, int N> void func(T (&arr)[N]);

T 是一个类型参数，它通过class或typename关键字指定。N 是一个非类型参数，用来传递数据的值，而不是类型，它和普通函数的形参一样，都需要指明具体的类型。类型参数和非类型参数都可以用在函数体或者类体中。

当调用一个函数模板或者通过一个类模板创建对象时，非类型参数会被用户提供的、或者编译器推断出的值所取代。

在函数模板中使用非类型参数

在《C++函数模板的重载》一节中，我们通过 Swap() 函数来交换两个数组的值，其原型为：

template<typename T> void Swap(T a[], T b[], int len);

形参 len 用来指明要交换的数组的长度，调用 Swap() 函数之前必须先通过sizeof求得数组长度再传递给它。

有读者可能会疑惑，为什么在函数内部不能求得数组长度，一定要通过形参把数组长度传递进去呢？这是因为数组在作为函数参数时会自动转换为数组指针，而sizeof只能通过数组名求得数组长度，不能通过数组指针求得数组长度，这在《数组和指针绝不等价，数组是另外一种类型》《数组到底在什么时候会转换为指针》两节中已经作了详细讲解。

多出来的形参 len 给编码带来了不便，我们可以借助模板中的非类型参数将它消除，请看下面的代码：

template<typename T, unsigned N> void Swap(T (&a)[N], T (&b)[N]){
    T temp;
    for(int i=0; i<N; i++){
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

T (&a)[N]表明 a 是一个引用，它引用的数据的类型是T [N]，也即一个数组；T (&b)[N]也是类似的道理。分析一个引用和分析一个指针的方法类似，编译器总是从它的名字开始读取，然后按照优先级顺序依次解析，这一点已在《只需一招，彻底攻克C语言指针》中进行了讲解。

调用 Swap() 函数时，需要将数组名字传递给它：

int a[5] = { 1, 2, 3, 4, 5 };
int b[5] = { 10, 20, 30, 40, 50 };
Swap(a, b);

编译器会使用数组类型int来代替类型参数T，使用数组长度5来代替非类型参数N。

下面是一个完整的示例：

#include <iostream>
using namespace std;

template<class T> void Swap(T &a, T &b);  //模板①：交换基本类型的值
template<typename T, unsigned N> void Swap(T (&a)[N], T (&b)[N]);  //模板②：交换两个数组

template<typename T, unsigned N> void printArray(T (&arr)[N]);  //打印数组元素

int main()
{
    //交换基本类型的值
    int m = 10, n = 99;
    Swap(m, n);  //匹配模板①
    cout<<m<<", "<<n<<endl;

    //交换两个数组
    int a[5] = { 1, 2, 3, 4, 5 };
    int b[5] = { 10, 20, 30, 40, 50 };
    Swap(a, b);  //匹配模板②
    printArray(a);
    printArray(b);

    return 0;
}

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

template<typename T, unsigned N> void Swap(T (&a)[N], T (&b)[N])
{
    T temp;
    for(int i=0; i<N; i++)
    {
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

template<typename T, unsigned N> void printArray(T (&arr)[N])
{
    for(int i=0; i<N; i++)
    {
        if(i == N-1)
        {
            cout<<arr[i]<<endl;
        }
        else
        {
            cout<<arr[i]<<", ";
        }
    }
}

运行结果：

99, 10
10, 20, 30, 40, 50
1, 2, 3, 4, 5

printArray() 也使用了非类型参数，这样只传递数组名字就能够打印数组元素了。

在类模板中使用非类型参数

C/C++ 规定，数组一旦定义后，它的长度就不能改变了；换句话说，数组容量不能动态地增大或者减小。这样的数组称为静态数组（Static array）。静态数组有时候会给编码代码不便，我们可以通过自定义的 Array 类来实现动态数组（Dynamic array）。所谓动态数组，是指数组容量能够在使用的过程中随时增大或减小。

动态数组的完整实现代码如下：

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;

template<typename T, int N>
class Array
{
public:
    Array();
    ~Array();
public:
    T & operator[](int i);  //重载下标运算符[]
    int length() const { return m_length; }  //获取数组长度
    bool capacity(int n);  //改变数组容量
private:
    int m_length;  //数组的当前长度
    int m_capacity;  //当前内存的容量（能容乃的元素的个数）
    T *m_p;  //指向数组内存的指针
};

template<typename T, int N>
Array<T, N>::Array()
{
    m_p = new T[N];
    m_capacity = m_length = N;
}

template<typename T, int N>
Array<T, N>::~Array()
{
    delete[] m_p;
}

template<typename T, int N>
T & Array<T, N>::operator[](int i)
{
    if(i<0 || i>=m_length)
    {
        cout<<"Exception: Array index out of bounds!"<<endl;
    }
    return m_p[i];
}

template<typename T, int N>
bool Array<T, N>::capacity(int n)
{
    if(n > 0)
    {  //增大数组
        int len = m_length + n;  //增大后的数组长度
        if(len <= m_capacity)
        {  //现有内存足以容纳增大后的数组
            m_length = len;
            return true;
        }
        else
        {  //现有内存不能容纳增大后的数组
            T *pTemp = new T[m_length + 2 * n * sizeof(T)];  //增加的内存足以容纳 2*n 个元素
            if(pTemp == NULL)
            {  //内存分配失败
                cout<<"Exception: Failed to allocate memory!"<<endl;
                return false;
            }
            else
            {  //内存分配成功
                memcpy( pTemp, m_p, m_length*sizeof(T) );
                delete[] m_p;
                m_p = pTemp;
                m_capacity = m_length = len;
            }
        }
    }
    else
    {  //收缩数组
        int len = m_length - abs(n);  //收缩后的数组长度
        if(len < 0)
        {
            cout<<"Exception: Array length is too small!"<<endl;
            return false;
        }
        else
        {
            m_length = len;
            return true;
        }
    }
}


int main()
{
    Array<int, 5> arr;

    //为数组元素赋值
    for(int i=0, len=arr.length(); i<len; i++)
    {
        arr[i] = 2*i;
    }
   
    //第一次打印数组
    for(int i=0, len=arr.length(); i<len; i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
   

    //扩大容量并为增加的元素赋值
    arr.capacity(8);
    for(int i=5, len=arr.length(); i<len; i++)
    {
        arr[i] = 2*i;
    }

    //第二次打印数组
    for(int i=0, len=arr.length(); i<len; i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;

    //收缩容量
    arr.capacity(-4);

    //第三次打印数组
    for(int i=0, len=arr.length(); i<len; i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;

    return 0;
}

运行结果：

0 2 4 6 8
0 2 4 6 8 10 12 14 16 18 20 22 24
0 2 4 6 8 10 12 14 16

Array 是一个类模板，它有一个类型参数T和一个非类型参数N，T 指明了数组元素的类型，N 指明了数组长度。

capacity() 成员函数是 Array 类的关键，它使得数组容量可以动态地增加或者减小。传递给它一个正数时，数组容量增大；传递给它一个负数时，数组容量减小。

之所以能通过[ ]来访问数组元素，是因为在 Array 类中以成员函数的形式重载了[ ]运算符，并且返回值是数组元素的引用。如果直接返回数组元素的值，那么将无法给数组元素赋值。

非类型参数的限制

非类型参数的类型不能随意指定，它受到了严格的限制，只能是一个整数，或者是一个指向对象或函数的指针（也可以是引用）。引用和指针在本质上是一样的，我们已在《引用在本质上是什么，它和指针到底有什么区别》中讲到。

1) 当非类型参数是一个整数时，传递给它的实参，或者由编译器推导出的实参必须是一个常量表达式，例如10、2 * 30、18 + 23 - 4等，但不能是n、n + 10、n + m等（n 和 m 都是变量）。

对于上面的 Swap() 函数，下面的调用就是错误的：

int len;
cin>>len;
int a[len];
int b[len];
Swap(a, b);

对上面的 Array 类，以下创建对象的方式是错误的：

int len;
cin>>len;
Array<int, len> arr;

这两种情况，编译器推导出来的实参是 len，是一个变量，而不是常量。

2) 当非类型参数是一个指针（引用）时，绑定到该指针的实参必须具有静态的生存期；换句话说，实参必须存储在虚拟地址空间中的静态数据区。局部变量位于栈区，动态创建的对象位于堆区，它们都不能用作实参。