C++变量模板的实现示例

template <typename t>
constexpr t pi = t(3.14159265358979323846l);

// 显式指定类型
float area_f = pi<float> * radius * radius;
double area_d = pi<double> * radius * radius;
long double area_ld = pi<long double> * radius * radius;

// 在c++17后，结合ctad（类模板参数推导）的上下文，有时可以隐式推导
// 但变量模板本身不支持参数推导，必须显式指定。

// 旧方法：类模板静态成员
template <typename t>
struct mathconstants {
    static constexpr t pi = t(3.14159265358979323846l);
};
// 使用时：mathconstants<double>::pi

// 新方法：变量模板
template <typename t>
constexpr t pi = t(3.14159265358979323846l);
// 使用时：pi<double>

// 函数模板：一个计算圆周率的函数
template <typename t>
constexpr t get_pi() { return t(3.14159265358979323846l); }

// 变量模板：圆周率常量本身
template <typename t>
constexpr t pi = t(3.14159265358979323846l);

// 使用对比
auto x = get_pi<double>(); // 函数调用
auto y = pi<double>;       // 直接使用常量

constexpr double pi_double = 3.141592653589793; // 仅double类型
// 变量模板则可以提供 float, double, long double 等多种精度的版本。

// 带有非类型模板参数的变量模板
template <int n>
constexpr int factorial = n * factorial<n - 1>;

template <>
constexpr int factorial<0> = 1; // 全特化

// 使用
static_assert(factorial<5> == 120);

// 类似于标准库的实现方式
template <typename t, typename u>
constexpr bool is_same_v = false;

template <typename t>
constexpr bool is_same_v<t, t> = true; // 偏特化：当两个类型相同时为true

namespace physics {
    template <typename t>
    constexpr t avogadro_number = t(6.02214076e23l);

    template <typename t>
    constexpr t planck_constant = t(6.62607015e-34l);

    template <typename t>
    constexpr t speed_of_light = t(299792458.0l);
}

// 在计算中使用，自动匹配计算精度
template <typename floatt>
floatt calculate_energy(floatt wavelength) {
    // 公式：e = h * c / λ
    return physics::planck_constant<floatt> * physics::speed_of_light<floatt> / wavelength;
}

auto energy_double = calculate_energy<double>(550e-9); // 使用double精度常数
auto energy_float = calculate_energy<float>(550e-9f);  // 使用float精度常数，避免隐式转换损失

// c++11/14 风格
static_assert(std::is_integral<int>::value, "");
using cleantype = std::remove_const_t<const int>;

// c++17 风格（使用了变量模板和别名模板）
static_assert(std::is_integral_v<int>, "");
using cleantype = std::remove_const_t<const int>;

template <typename t>
struct is_contiguous_container {
    static constexpr bool value = /* 复杂的编译期判断逻辑 */;
};

// 提供便捷的变量模板
template <typename t>
constexpr bool is_contiguous_container_v = is_contiguous_container<t>::value;

// 使用
if constexpr (is_contiguous_container_v<myvec>) {
    // 优化路径
}

enum class databaseerror { connectionfailed, querytimeout, constraintviolation };
enum class networkerror { timeout, hostnotfound, refused };

template <typename errorcode>
constexpr std::string_view error_message = "unknown error";

// 为特定错误类型特化
template <>
constexpr std::string_view error_message<databaseerror::connectionfailed> = "database connection failed.";

template <>
constexpr std::string_view error_message<networkerror::timeout> = "network request timed out.";

// 使用
auto db_msg = error_message<databaseerror::connectionfailed>; // 编译期获取字符串
static_assert(error_message<databaseerror::connectionfailed>.size() > 0);

struct fastalgorithm { void solve() { /*...*/ } };
struct accuratealgorithm { void solve() { /*...*/ } };

template <typename problemtype>
constexpr auto algorithm_selector = fastalgorithm{}; // 默认策略

template <>
constexpr auto algorithm_selector<doubleprecisionproblem> = accuratealgorithm{}; // 特定问题的策略

// 使用
auto solver = algorithm_selector<myproblem>;
solver.solve();

// 一个简单的编译期字符串哈希变量模板（djb2算法）
template <std::size_t n>
constexpr std::size_t string_hash(const char (&str)[n]) {
    std::size_t hash = 5381;
    for (std::size_t i = 0; i < n - 1; ++i) { // n-1 排除结尾的'\0'
        hash = ((hash << 5) + hash) + str[i];
    }
    return hash;
}

// 定义变量模板，将哈希值存储为编译期常量
template <std::size_t n>
constexpr std::size_t hash_v = string_hash(n);

// 注意：这里需要一点技巧，因为string_hash需要字符串参数，不能直接用作变量模板的初始化器。
// 更常见的做法是使用constexpr函数，或者用宏来包装。
// 一种替代模式是结合宏（仅用于演示，实际项目慎用宏）：
#define define_hash(str) constexpr std::size_t hash_##str = string_hash(#str)

define_hash(option1); // 生成 hash_option1 = 某个编译期值
define_hash(option2);

// 然后在编译期比较
if constexpr (hash_option1 == hash_option2) { /* ... */ }

// my_constants.h
#pragma once

template <typename t>
inline t default_tolerance = t(1e-5); // 非constexpr，但inline，可以在头文件中定义

// 多个翻译单元包含此头文件，链接时不会发生重复定义错误。

// common.h
template<typename t>
t global_threshold; // 非constexpr，非inline

// a.cpp
#include "common.h"
auto x = global_threshold<int>; // 使用

// b.cpp
#include "common.h"
// 没有定义 global_threshold<int>

// common.h
template<typename t>
t global_threshold = t(10); // 非constexpr，非inline

// a.cpp 和 b.cpp 都包含了 common.h 并使用了 global_threshold<int>

template <typename t>
t& get_complex_global() {
    static t instance = initialize_complex_value(); // 线程安全（c++11起）
    return instance;
}

// 策略类
struct jsonserializer { std::string serialize(const data&); };
struct xmlserializer { std::string serialize(const data&); };
struct binaryserializer { std::string serialize(const data&); };

// 编译期策略映射：根据“模式”类型选择序列化器类型
template <typename formattag>
constexpr auto serializer_for = jsonserializer{}; // 默认

template <>
constexpr auto serializer_for<struct xmlformat> = xmlserializer{};

template <>
constexpr auto serializer_for<struct binaryformat> = binaryserializer{};

// 使用
using chosenformat = xmlformat; // 在配置或类型推导中决定
auto result = serializer_for<chosenformat>.serialize(my_data);