C++实现模板中的非类型参数的方法

#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 = 90;
 swap(m,n);
 cout << "m = " << m << ", n = " << 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<class 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] << ", ";
 }
 }
}

#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)];
  if (null==ptemp){
  cout << "exception: failed to allocate memory!";
  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;
 }

 cout << "first print:" << endl;
 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;
 }

 cout << endl;
 cout << "second print:" << endl;
 for (int i = 0, len = arr.length(); i < len;i++){
 cout << arr[i] << " ";
 }
 cout << endl;

 arr.capacity(-4);
 cout << "third print: " << endl;
 for (int i = 0, len = arr.length(); i < len; i++){
 cout << arr[i] << " ";
 }
 cout << endl;

 return 0;
}

template<double val>      // error： 浮点数不可作为非类型模板参数
double process(double v)
{
  return v * val;
}

template<std::string name>   // error：类对象不能作为非类型模板参数
class myclass
{}


稍作变通，我们即可使编译通过：

template<double* pval>
double process(const double& x)
{
  return x * (*pval);
}

template<const char* name>
class myclass
{
  ...
}

double val = 10;
double res = process<&val>(20);   // error: 表达式必须含有常量值

myclass<"hello"> x;         // error: 模板参数不能引用非外部实体

const char* s = "hello";
myclass<s> x;            // error: 表达式必须含有常量值

// b.cpp
double val = 3.14159265;
char str[] = "hello";

// a.hpp
extern double val;
extern char str[];

// a.cpp
#include "a.hpp"

double res = process<&val>(10);
myclass<str> x;