变量模板和非类型模板参数

变量模板

变量模板（Variable Templates）是C++14引入的一个新特性，它允许我们定义模板化的变量。我们可以创建一个变量，其类型或值依赖于模板参数。

基本语法

变量模板的声明和定义类似于函数模板。基本语法如下：

// 变量模板
template<typename T>
constexpr T pi = T(3.14159265358979323846);

用法

定义编译期常量

// 定义变量模板
template<typename T>
constexpr T max_value = std::numeric_limits<T>::max();

template<typename T>
constexpr T pi_v = T(3.14159265358979323846);

template<typename T>
constexpr T e_v = T(2.71828182845904523536);

int main()
{
    std::cout << "Max int: " << max_value<int> << std::endl;
    std::cout << "Max double: " << max_value<double> << std::endl;

    std::cout << "Pi as float: " << pi_v<float> << std::endl;
    std::cout << "Pi as double: " << pi_v<double> << std::endl;

    std::cout << "e as float: " << e_v<float> << std::endl;
    std::cout << "e as double: " << e_v<double> << std::endl;
    return 0;
}

输出如下：

Max int: 2147483647
Max double: 1.79769e+308
Pi as float: 3.14159
Pi as double: 3.14159
e as float: 2.71828
e as double: 2.71828

变量模板特化

// 主模板
template<typename T>
constexpr T default_value = T{};

// 全特化
template<>
constexpr int default_value<int> = 42;

template<>
constexpr double default_value<double> = 3.14;


// std::string 不能用作 constexpr，下面代码有错
// template<>
// constexpr std::string default_value<std::string> = "Hello";

template<>
constexpr const char* default_value<const char*> = "Hello";


// 偏特化（通过重载实现类似效果）
template<typename T>
constexpr T* default_value<T*> = nullptr;

int main()
{
    std::cout << "Default int: " << default_value<int> << std::endl;
    std::cout << "Default double: " << default_value<double> << std::endl;
    std::cout << "Default const char*: " << default_value<const char*> << std::endl;
    std::cout << "Default int*: " << default_value<int*> << std::endl;
    return 0;
}

输出：

Default int: 42
Default double: 3.14
Default const char*: Hello
Default int*: 0

非类型模板参数

非类型模板参数是指模板参数不是类型，而是具体的值。例如，下述代码用于定义 Fibonacci 数列。

template<int N>
constexpr int fibonacci = fibonacci<N - 1> +fibonacci<N - 2>;

template<>
constexpr int fibonacci<0> = 0;

template<>
constexpr int fibonacci<1> = 1;

上述代码中，constexpr 关键字表示这是编译期常量，确保变量模板可以在编译期使用。

目前，非类型模板参数只能是以下几种类型（C++17后放宽）：

• 整型（包括枚举）
• 指针类型
• 引用类型
• 指向成员的指针

注意：不支持浮点类型和类类型。

简单用法

基本用法

// 整型类型
template<int N>
class Array 
{
public:
    int data[N];
    int size() const { return N; }
};

// 指针类型
template<const char* Str>
class StringWrapper 
{
public:
    const char* get() const { return Str; }
};

// 引用类型
template<int& Ref>
class ReferenceWrapper 
{
public:
    int get() const { return Ref; }
    void set(int value) { Ref = value; }
};

// 枚举类型
enum class Color { Red, Green, Blue };
template<Color C>
class ColorTemplate 
{
public:
    static constexpr Color value = C;
};

编译时计算

template<int N>
constexpr int factorial = N * factorial<N-1>;

template<>
constexpr int factorial<0> = 1;

template<int Base, int Exp>
constexpr int power = Base * power<Base, Exp - 1>;

template<int Base>
constexpr int power<Base, 0> = 1;

int main()
{
    std::cout << "Factorial(5): " << factorial<5> << std::endl;
    std::cout << "2^5 = " << power<2, 5> << std::endl;
    return 0;
}

输出如下：

Factorial(5): 120
2^5 = 32

非类型模板参数的链接性

先看一段代码：

constexpr int arr[3] = {1, 2, 3};
template<const int* P> struct ArrayPtr {};

int main()
{
    constexpr int arr2[3] = {1, 2, 3}; 
    ArrayPtr<arr> a;
    ArrayPtr<arr2> b; // error: 'arr2' is not a valid template argument of type 'const int*' because 'arr2' has no linkage
}

ArrayPtr<arr2> b 在使用居然报错了。这个问题涉及到 C++ 模板非类型参数和链接性的规则。arr 和 arr2 的链接性是不相同的：

• arr 是全局变量，具有外部链接。
• arr2 是局部变量（在 main 函数内），无链接。

C++ 标准对非类型模板参数的要求：

1. 整型（包括 int, char, bool, enum 等）：

• 只需要是常量表达式，可以是局部 constexpr 变量。

1. 指针/引用：

• 必须指向具有外部或内部链接的实体。
• 不能指向局部变量（无链接）

要让 arr2 可用作模板参数，可以使用 static 关键字或者使用命名空间：

// 使用 static
int main()
{
    static constexpr int arr2[3] = {1, 2, 3};  // 内部链接
    ArrayPtr<arr2> b;  // 现在合法
}

// 使用命名空间作用域
namespace 
{
    constexpr int arr2[3] = {1, 2, 3};  // 内部链接
}

int main()
{
    ArrayPtr<arr2> b;  // 合法
}

这个限制主要是为了确保模板实例化的一致性：

• 有链接的实体在程序的整个生命周期中都有唯一的地址。
• 无链接的实体（如局部变量）可能在不同的翻译单元或上下文中有不同的实例。
• 模板需要在编译时确定唯一的标识符。