3. 非类型模板参数

## 前言
模板参数未必都是typename的关键字，也可以是**某种类型的`变量`**

# 类模板的非类型参数
## 声明
```cpp
template<typename T, std::size_t Maxsize>
class Stack;
```

## 定义
```cpp
template<typename T, std::size_t Maxsize>   //要理解这句
class Stack {
	...
};
```
`typename T`这类型
`std::size_t Maxsize`这是变量

## 引用
```cpp
template<typename T, std::size_t Maxsize>
class Stack {
private:
   std::array<T, Maxsize> elems; // elements
   std::size_t numElems; // current number of elements

public:
   Stack(); // constructor
   void push(T const& elem); // push element
   void pop(); // pop element
   T const& top() const; // return top element
   bool empty() const { //return whether the stack is empty
      return numElems == 0;
   }
   std::size_t size() const { //return current number of elements
      return numElems;
   }
};

template<typename T, std::size_t Maxsize>
Stack<T, Maxsize>::Stack() : numElems(0) {
   // nothing to do in constructor
}

template<typename T, std::size_t Maxsize>
void Stack<T, Maxsize>::push(T const& elem) {
   assert(numElems < Maxsize);
   elems[numElems] = elem; // append element
   ++numElems; // increment number of elements
}

template<typename T, std::size_t Maxsize>
void Stack<T, Maxsize>::pop() {
   assert(!elems.empty());
   --numElems; // decrement number of elements
}

template<typename T, std::size_t Maxsize>
T const& Stack<T, Maxsize>::top() const {
   assert(!elems.empty());
   return elems[numElems-1]; // return last element
}

int main()
{
   Stack<int,20> int20Stack; // stack of up to 20 ints
   Stack<int,40> int40Stack; // stack of up to 40 ints
   Stack<std::string,40> stringStack; // stack of up to 40 strings
   // manipulate stack of up to 20 ints
   int20Stack.push(7);
   std::cout << int20Stack.top() << std::endl;
   int20Stack.pop();
   // manipulate stack of up to 40 strings
   stringStack.push("hello");
   std::cout << stringStack.top() << std::endl;
   stringStack.pop();
   return 0;
}
```

也可是指定非模板参数的默认值。虽然说对于本例来说，并没有多大意义，但是只是为了说明赋默认值是可行的。eg：
```cpp
template<typename T, std::size_t Maxsize = 100>   \\Maxsize默认值是100
class Stack {
…
};
```

# 函数模板的非类型参数
## 声明
```cpp
template<int Val, typename T>
T addValue (T x);
```

## 定义
```cpp
template<int Val, typename T>
T addValue (T x)
{
	return x + Val;
}
```

## 引用
例如当使用 C++标准库给一个集合中的所有元素增加某个值的时候， 可以将这个函数模板的一个实例化版本用作第 4个参数：
```cpp
std::transform (source.begin(), source.end(), //start and end of source
							dest.begin(), //start of destination
							addValue<5,int>); // operation
```
第 4 个参数是从 addValue<>()实例化出一个可以给传入的 int 型参数加 5 的函数实例。 这一
实例会被用来处理集合 source 中的所有元素， 并将结果保存到目标集合 dest 中。

>注意在这里必须将 addValue<>()的模板参数 T 指定为 int 类型。 因为类型推断只会对立即发
生的调用起作用， 而 std::transform()又需要一个完整的类型来推断其第四个参数的类型。 目
前还不支持先部分地替换或者推断模板参数的类型， 然后再基于具体情况去推断其余的模板
参数。

**同样也可以基于前面的模板参数推断出当前模板参数的类型。 比如可以通过传入的非类型模
板参数推断出返回类型**
```cpp
template<auto Val, typename T = decltype(Val)>
T foo();
```

或者可以通过如下方式确保传入的非类型模板参数的类型和类型参数的类型一致：
```cpp
template<typename T, T Val = T{}>
T bar();
```

# 非类型模板参数的限制
## 类型限制
使用非类型模板参数是有限制的。 通常它们只能是整形常量（ 包含枚举），指向对象/函数/成员的指针。对象或者函数对象的左值引用。或者是 std::nullptr_t（类型是 nullptr）

## 避免无效表达式
非类型模板参数可以是任何编译器表达式。比如：
```cpp
template<int I, bool B>
class C;
…
C<sizeof(int) + 4, sizeof(int)==4> c;
```
不过如果在表达式中使用了 operator >， 就必须将相应表达式放在括号里面， 否则>会被作为
模板参数列表末尾的>， 从而截断了参数列表：
```cpp
C<42, sizeof(int) > 4> c; // ERROR: first > ends the template argument list
C<42, (sizeof(int) > 4)> c; // OK
```

# 使用 auto 作为非模板类型参数的类型
从 C++17 开始， 可以不指定非类型模板参数的具体类型（ 代之以 auto） ， 从而使其可以用
于任意有效的非类型模板参数的类型。 通过这一特性， 可以定义如下更为泛化的大小固定的
Stack 类：
```cpp
#include <array>
#include <cassert>
template<typename T, auto Maxsize>
class Stack {
public:
	using size_type = decltype(Maxsize);
private:
	std::array<T,Maxsize> elems; // elements
	size_type numElems; // current number of elements
public:
	Stack(); // constructor
	void push(T const& elem); // push element
	void pop(); // pop element
	T const& top() const; // return top element
	bool empty() const { //return whether the stack isempty
	return numElems == 0;
}

size_type size() const { //return current number of elements
	return numElems;
}
};
// constructor
template<typename T, auto Maxsize>
Stack<T,Maxsize>::Stack ()
: numElems(0) //start with no elements
{
	// nothing else to do
}

template<typename T, auto Maxsize>
void Stack<T,Maxsize>::push (T const& elem)
{
	assert(numElems < Maxsize);
	elems[numElems] = elem; // append element
	++numElems; // increment number of elements
}
template<typename T, auto Maxsize>
void Stack<T,Maxsize>::pop ()
{
	assert(!elems.empty());
	--numElems; // decrement number of elements
}

template<typename T, auto Maxsize>
T const& Stack<T,Maxsize>::top () const
{
	assert(!elems.empty());
	return elems[numElems-1]; // return last element
}
```
通过使用 auto 的如下定义：
```cpp
template<typename T, auto Maxsize>
class Stack {
…
};
```
定义了类型待定的 Maxsize。 它的类型可以是任意非类型参数所允许的类型。
在模板内部， 既可以使用它的值：
```cpp
std::array<T,Maxsize> elems; // elements
```
也可以使用它的类型：
```cpp
using size_type = decltype(Maxsize);
```
然后可以将它用于成员函数 size()的返回类型：
```cpp
size_type size() const { //return current number of elements
	return numElems;
}
```

从 C++14 开始， 也可以通过使用 auto， 让编译器推断出具体的返回类型：
```cpp
auto size() const { //return current number of elements
	return numElems;
}
```