如何限制Dynamic类模板构造函数仅支持指定类型（含std::ptrdiff_t）？

要实现你的需求，核心思路是通过**SFINAE（Substitution Failure Is Not An Error）**技术，让模板构造函数仅对你允许的类型生效，同时排除那些你不想支持的整数类型（int、unsigned int、long等）。具体步骤如下：

1. 定义类型判断Trait #

首先，我们需要一个自定义类型 trait，用来判断某个类型是否是Dynamic类允许存储的类型。这个trait会帮我们过滤掉那些不需要的整数类型。

#include <type_traits>
#include <vector>
#include <cstddef> // 包含std::ptrdiff_t和std::size_t

// 基础模板，默认所有类型不允许
template <typename T>
struct is_allowed_type_base : std::false_type {};

// 用宏简化允许类型的特化，避免重复代码
#define ALLOW_TYPE(T) \
template <> \
struct is_allowed_type_base<T> : std::true_type {};

// 字符类型
ALLOW_TYPE(unsigned char);
ALLOW_TYPE(signed char);
ALLOW_TYPE(char);

// 你指定的整数类型
ALLOW_TYPE(std::ptrdiff_t);
ALLOW_TYPE(std::size_t);

// 浮点类型
ALLOW_TYPE(float);
ALLOW_TYPE(double);

// 处理std::vector：只要元素类型允许，vector就允许
template <typename U>
struct is_allowed_type_base<std::vector<U>> : is_allowed_type_base<U> {};

// 处理const、volatile、引用等限定符，确保判断准确
template <typename T>
struct is_allowed_type 
    : is_allowed_type_base<std::remove_cv_t<std::remove_reference_t<T>>> {};

// 辅助变量模板，简化使用
template <typename T>
constexpr bool is_allowed_type_v = is_allowed_type<T>::value;

这里通过std::remove_cv_t和std::remove_reference_t处理const、volatile和引用类型，确保即使传入const unsigned char&这样的参数，也能被正确识别为允许的类型。

2. 用SFINAE约束模板构造函数 #

接下来，在Dynamic类中，我们给模板构造函数添加std::enable_if约束，只有当is_allowed_type_v<T>为true时，这个构造函数才会被编译器考虑：

enum class Type {
    // 这里列出你所有支持的类型ID，示例如下：
    UnsignedChar,
    SignedChar,
    Char,
    PtrdiffT,
    SizeT,
    Float,
    Double,
    VectorUnsignedChar,
    // ... 其他200种类型
};

class Dynamic {
private:
    Type type_;
    std::uint64_t data_;

    // 辅助函数：根据类型存储数据（示例实现）
    template <typename T>
    void store_value(const T& x) {
        if constexpr (std::is_same_v<T, unsigned char>) {
            type_ = Type::UnsignedChar;
            data_ = static_cast<std::uint64_t>(x);
        } else if constexpr (std::is_same_v<T, std::ptrdiff_t>) {
            type_ = Type::PtrdiffT;
            data_ = static_cast<std::uint64_t>(x);
        } else if constexpr (std::is_same_v<T, std::vector<unsigned char>>) {
            // 注意：这里只是示例，实际存储vector需要额外处理内存管理
            type_ = Type::VectorUnsignedChar;
            data_ = reinterpret_cast<std::uint64_t>(new std::vector<unsigned char>(x));
        }
        // ... 其他类型的存储逻辑
    }

public:
    Dynamic() = default;

    // 模板构造函数：仅允许is_allowed_type_v<T>为true的类型
    template <typename T, typename = std::enable_if_t<is_allowed_type_v<T>>>
    Dynamic(const T& x) {
        store_value(x);
    }

    // 显式声明拷贝/移动构造函数和赋值运算符，避免被模板构造函数覆盖
    Dynamic(const Dynamic&) = default;
    Dynamic(Dynamic&&) = default;
    Dynamic& operator=(const Dynamic&) = default;
    Dynamic& operator=(Dynamic&&) = default;

    // 析构函数：处理动态分配对象的内存释放（示例）
    ~Dynamic() {
        if (type_ == Type::VectorUnsignedChar) {
            delete reinterpret_cast<std::vector<unsigned char>*>(data_);
        }
        // ... 其他类型的清理逻辑
    }
};

3. 效果验证 #

现在，你的代码会呈现以下行为：

• 允许的类型可以直接构造：

  std::ptrdiff_t large_num = 10'000'000'000;
  il::Dynamic d0 = large_num; // 正常编译，存储std::ptrdiff_t类型
  
  unsigned char uc = 255;
  il::Dynamic d1 = uc; // 正常编译
  
  std::vector<double> vec = {1.0, 2.0};
  il::Dynamic d2 = vec; // 正常编译
  

• 不允许的类型会触发编译错误：

  il::Dynamic d3 = 1'000'000'000; // 错误：int类型不被允许
  il::Dynamic d4 = 10'000'000'000LL; // 错误：long long类型不被允许
  

  此时用户必须显式转换为允许的类型才能编译：

  il::Dynamic d3 = static_cast<std::ptrdiff_t>(1'000'000'000); // 正常编译
  

关键注意事项 #

• 拷贝构造函数优先级：必须显式声明Dynamic(const Dynamic&) = default;，否则编译器可能会将模板构造函数误匹配为拷贝构造函数，导致意外行为。
• 动态内存管理：如果存储像std::vector这样的复杂类型，需要在析构函数中正确释放内存，避免内存泄漏。
• 类型覆盖完整：确保is_allowed_type_base的特化覆盖了你Type枚举中的所有200种类型，避免遗漏。

内容的提问来源于stack exchange，提问作者InsideLoop