1 变量模板在 C++14 中的引入与扩展
在 C++14 中，变量模板的引入与扩展为编程带来了许多便利，特别是在泛型编程方面。这一特性允许我们直接定义模板变量，而不需要将其包装在模板类或模板函数中，从而使得代码更加直观和简洁。
首先，我们来详细了解一下 C++14 之前模板的使用限制。在 C++14 之前，虽然模板已经可以用于定义类型和函数，但对于变量，我们只能在模板类或模板函数中定义它们。这导致在某些情况下，代码可能会变得冗余和复杂。例如，如果我们想为每种类型定义一个常量，可能需要定义一个模板类，并在其中定义这个常量。这样的做法不仅增加了代码的复杂性，也使得使用这个常量变得不那么直观。
比如，假设想要在 C++11 中为每种类型定义一个模板常量 PI：
// 假设我们想要在C++11中为每种类型定义一个模板常量PI
// 定义一个模板类来包含常量PI
template<typename T>
struct PiValue {
static constexpr T value = T(3.14159265358979323846);
};
// 使用这个模板类来获取特定类型的PI值
int main() {
double piDouble = PiValue<double>::value;
float piFloat = PiValue<float>::value;
// ...
return 0;
}
上面的代码定义了一个模板类 PiValue，它包含一个静态常量成员 value，这个常量成员的类型由模板参数 T 决定。然后，在 main 函数中，通过 PiValue<double>::value 和 PiValue<float>::value 来获取 double 和 float 类型的 PI 值。这种方法虽然可行，但确实增加了代码的复杂性，并且每次想要使用 PI 值时都需要通过类来访问，不够直观。
然而，C++14 引入了变量模板，这一特性极大地改变了这种状况。变量模板允许我们直接定义模板变量，使得我们可以更加直观和简洁地定义和使用模板变量。这种直接的定义方式不仅提高了代码的可读性，也降低了代码的复杂性。
针对上面的问题，可以更简洁地实现同样的功能：
// C++14 引入变量模板后，我们可以直接定义PI变量模板
template<typename T>
constexpr T pi = T(3.14159265358979323846);
// 使用变量模板PI，代码更简洁直观
int main() {
double piDouble = pi<double>;
float piFloat = pi<float>;
return 0;
}
在上面 C++14 的示例中，直接定义了一个名为 pi 的变量模板，它可以为任何类型生成一个 PI 常量。在 main 函数中，可以直接通过 pi<double> 和 pi< 来获取对应类型的 PI 值，或者使用类型推导让编译器自动推断 pi 的类型。这种方法不仅减少了代码的复杂性，也使得使用常量变得更加直观。
除了上面的优势，C++14 对变量模板的扩展也使得其应用更加广泛。通过变量模板，我们可以定义一系列变量或静态数据成员，使得模板的返回值进一步扩大。这使得变量模板在编写泛型代码时，能够提供更加灵活和强大的功能。
在实际使用中，变量模板的实例化也非常方便。例如，我们可以为不同类型的变量模板提供不同的实例化，每个实例化都有自己独立的地址。这种特性使得变量模板在处理不同类型的数据时，能够保持高度的灵活性和独立性。
2 变量模板的语法与声明
（1）语法与声明
变量模板的声明使用 template 关键字，后面紧跟一个模板参数列表（可以是类型参数或值参数），然后是变量的声明。下面是一个简单的例子：
template<typename T>
constexpr T pi = T(3.14159265358979323846);
在这个例子中，pi 是一个变量模板，它的类型由模板参数 T 决定。constexpr 表示这个变量是一个常量表达式，可以在编译时求值。
（2）实例化
double radius = 1.0;
double circle_area = pi<double> * radius * radius; // 指定类型
在上面的代码中，pi<double> 显式地指定了 pi 变量的类型为 double。
（3）默认值与多个模板参数
变量模板也可以有默认模板参数，这使得使用更加灵活：
template<typename T = double>
constexpr T pi = T(3.14159265358979323846);
double circle_area = pi<> * radius * radius; // 没有明确指定类型
在这个版本中，如果没有明确指定T的类型，它将默认为double。
（4）此外，变量模板也可以有多个模板参数：
template<typename T, int N>
constexpr T factorial = N * factorial<T, N - 1>;
template<typename T>
constexpr T factorial<T, 0> = 1; // 特化以结束递归
在这个例子中，factorial 是一个递归定义的变量模板，用于计算阶乘。它有两个模板参数：类型 T 和整数 N。递归的基准情况是当 N 为 0 时，factorial 的值为 1。
（5）注意事项
- 变量模板必须在所有使用它的翻译单元中可见，否则链接器可能会报错。
- 变量模板的定义必须出现在所有使用它的地方之前，或者通过包含头文件的方式确保其可见性。
- 由于变量模板在编译时实例化，因此如果模板参数是复杂的类型，可能会导致编译时间增加。
3 变量模板的使用示例
3.1 基础示例
（1）定义和使用简单的变量模板
#include <iostream>
// 定义一个变量模板
template<typename T = double>
constexpr T pi = T(3.14159265358979323846);
int main() {
// 使用默认类型
double circleArea = pi<> * 5.0 * 5.0;
std::cout << "Circle area: " << circleArea << std::endl;
// 也可以显式指定类型
float piFloat = pi<float>;
std::cout << "Pi as float: " << piFloat << std::endl;
return 0;
}
上面代码的输出为：
Circle area: 78.5398
Pi as float: 3.14159
这个例子定义了一个变量模板 pi，在 circleArea 的计算中，编译器使用默认类型 double，而在 piFloat 的定义中，显式地指定了 pi 的类型为 float。
（2）使用变量模板定义类型无关的常量数组
#include <iostream>
#include <array>
// 定义一个变量模板，用于创建固定大小的数组
template<typename T, std::size_t N>
constexpr std::array<T, N> zeros = {};
int main() {
// 使用变量模板创建整数数组
auto intArray = zeros<int, 5>;
for (int value : intArray) {
std::cout << value << ' ';
}
std::cout << std::endl;
// 使用变量模板创建浮点数数组
auto floatArray = zeros<float, 3>;
for (float value : floatArray) {
std::cout << value << ' ';
}
std::cout << std::endl;
return 0;
}
上面代码的输出为：
0 0 0 0 0
0 0 0
这个例子定义了一个变量模板 zeros，它用于创建包含指定类型和大小的零值数组。在 main 函数中，分别用它创建了整数数组和浮点数数组。
（3）使用变量模板和模板元编程创建类型相关的常量
#include <iostream>
#include <type_traits>
// 定义一个变量模板，用于创建基于类型大小的常量
template<typename T>
constexpr std::size_t typeSize = sizeof(T);
int main() {
// 输出int类型的大小
std::cout << "Size of int: " << typeSize<int> << std::endl;
// 输出double类型的大小
std::cout << "Size of double: " << typeSize<double> << std::endl;
// 使用条件编译检查类型是否为指针
if (std::is_pointer<decltype(typeSize<int*>)>::value) {
std::cout << "typeSize<int*> is a pointer type." << std::endl;
}
else {
std::cout << "typeSize<int*> is not a pointer type." << std::endl;
}
return 0;
}
上面代码的输出为：
Size of int: 4
Size of double: 8
typeSize<int*> is not a pointer type.
这个例子定义了一个变量模板 typeSize，它返回给定类型 T 的大小（以字节为单位）。然后在 main 函数中用它来获取 int 和 double 类型的大小，并使用 std::is_pointer 来检查 typeSize<int*> 是否是指针类型。
3.2 在函数中使用变量模板
在函数中使用 C++14 的变量模板时，可以像使用普通变量一样使用它们。可以使用默认类型，或者也可以显式地指定类型。下面是一个示例，展示了如何在函数内部使用变量模板：
#include <iostream>
#include <vector>
// 定义一个变量模板
template<typename T>
constexpr T pi = T(3.14159265358979323846);
// 一个函数，它接受一个半径并使用pi变量模板来计算圆的面积
template<typename T>
T calculateCircleArea(T radius) {
return pi<T> * radius * radius;
}
int main() {
// 使用double类型的半径调用函数
double areaDouble = calculateCircleArea(5.0);
std::cout << "Circle area with double: " << areaDouble << std::endl;
// 使用float类型的半径调用函数
float areaFloat = calculateCircleArea(5.0f);
std::cout << "Circle area with float: " << areaFloat << std::endl;
// 使用显式推导的pi类型
auto areaAuto = calculateCircleArea(5); // 这里的5是int类型，所以pi的类型也会被推导为int
std::cout << "Circle area with int: " << static_cast<double>(areaAuto) << std::endl; // 需要显式转换为double来打印，因为int乘以int得到int
return 0;
}
上面代码的输出为：
Circle area with double: 78.5398
Circle area with float: 78.5398
Circle area with int: 75
上面的代码定义了一个函数 calculateCircleArea，它接受一个模板参数 T，表示半径的类型。在函数内部，使用 pi<T>来计算圆的面积。由于 pi 是一个变量模板，它会根据传入的半径类型 T 进行编译。
在 main 函数中，分别使用 double、float 和 int 类型的半径调用 calculateCircleArea 函数，并打印出计算得到的面积。注意，当使用 int 类型的半径时，由于整数乘法会丢失小数部分，因此打印结果前需要将其转换为 double 类型。
此外，还可以在函数内部直接使用变量模板，而不需要通过模板参数传递类型。例如：
#include <iostream>
// 变量模板定义
template<typename T>
constexpr T pi = T(3.14159265358979323846);
// 一个非模板函数，它直接使用pi变量模板
void printCircleArea(double radius) {
double area = pi<double> * radius * radius;
std::cout << "Circle area: " << area << std::endl;
}
int main() {
printCircleArea(5.0); // 输出使用double类型的pi计算得到的面积
return 0;
}
上面代码的输出为：
Circle area: 78.5398
在这个例子中，printCircleArea 是一个非模板函数，它直接在函数内部使用 pi<double> 来计算面积。由于显式指定了 pi 的类型为 double，因此不需要通过模板参数来传递类型信息。这样可以使代码更加简洁和直观。
3.3 变量模板与静态数据成员的结合使用
在 C++14 中，变量模板可以与类的静态数据成员结合使用，从而允许我们定义与类类型相关的全局常量或变量。通过将变量模板与静态成员结合，我们可以创建与类类型紧密相关的全局状态或配置，同时保持类型安全和代码的灵活性。
下面是一个示例，展示了如何将变量模板与类的静态数据成员结合使用：
#include <iostream>
// 定义一个变量模板，它使用类的静态成员作为类型参数
template<typename T>
constexpr auto MyVarTemplate = T::Value;
// 定义一个类模板，它包含一个静态数据成员
template<typename T>
class MyClass {
public:
// 静态数据成员，它的值将在类定义时确定
static constexpr T Value = T(42);
};
// 使用MyClass的特化来定义不同的值
template<>
class MyClass<double> {
public:
static constexpr double Value = 3.14159;
};
int main() {
// 使用变量模板与MyClass<int>的静态成员结合
std::cout << "MyVarTemplate for MyClass<int>: " << MyVarTemplate<MyClass<int>> << std::endl;
// 使用变量模板与MyClass<double>的特化静态成员结合
std::cout << "MyVarTemplate for MyClass<double>: " << MyVarTemplate<MyClass<double>> << std::endl;
return 0;
}
上面代码的输出为：
MyVarTemplate for MyClass<int>: 42
MyVarTemplate for MyClass<double>: 3.14159
这个例子定义了一个变量模板 MyVarTemplate，它接受一个类型参数 T，并引用了 T::Value 这个静态成员。然后，定义了一个类模板 MyClass，它有一个静态数据成员 Value，其值在类定义时确定。对于 MyClass<double>，这里提供了一个特化版本，其 Value 成员具有不同的值。
在 main 函数中，通过将 MyClass<int> 和 MyClass<double> 作为类型参数传递给 MyVarTemplate，来访问这些静态数据成员的值。由于 MyVarTemplate 是一个变量模板，它会根据提供的类型自动推导并引用相应的静态成员。
需要注意的是，静态数据成员必须在类定义中初始化，并且它们的值必须在编译时常量表达式中确定。上面的例子使用 constexpr 来确保这些条件得到满足。
通过将变量模板与类的静态数据成员结合使用，可以创建灵活且类型安全的全局配置或状态，这些配置或状态与特定的类类型紧密相关。这种方法允许在不增加代码复杂性的情况下，为不同的类类型定义不同的常量值或行为。