如何实现仅持有类型而非实例、具备std::tuple索引特性的constexpr工具类

刚好遇到过类似的需求！你要的其实是一个仅持有类型信息的元组——不需要存储任何对象实例，只通过模板参数包管理类型，同时支持按索引访问类型。C++标准库没有直接提供这个，但我们可以自己实现一个轻量版，完美解决你的问题。

核心问题分析 #

你当前用std::tuple<T...> tuple{}的问题在于：

• 它会强制实例化每个T的对象，哪怕你根本不需要这个对象
• 如果T的默认构造不是constexpr（或者你不想提供构造函数），整个consteval代码就会编译失败
• 你的场景只需要访问T的静态成员，完全不需要对象实例

解决方案：纯类型元组（TypeTuple） #

我们可以实现一个只持有类型、不存储任何实例的元组结构，再搭配索引获取类型的辅助模板，就能像std::tuple一样按索引访问类型，同时完全避免对象实例化的问题。

1. 实现纯类型元组与类型索引工具

#include <cstdint>
#include <array>

// 纯类型元组：仅持有类型参数包，无任何成员变量/实例
template <typename... Ts>
struct TypeTuple {};

// 辅助模板：按索引获取TypeTuple中的类型
template <size_t Idx, typename Tuple>
struct TypeGet;

// 递归特化：索引大于0时，递归取剩余包的第Idx-1个类型
template <size_t Idx, typename T, typename... Ts>
struct TypeGet<Idx, TypeTuple<T, Ts...>> : TypeGet<Idx - 1, TypeTuple<Ts...>> {};

// 终止条件：索引为0时，返回第一个类型
template <typename T, typename... Ts>
struct TypeGet<0, TypeTuple<T, Ts...>> {
    using Type = T;
};

// 便捷别名：简化类型获取的写法
template <size_t Idx, typename Tuple>
using TypeGet_t = typename TypeGet<Idx, Tuple>::Type;

2. 在你的MyBitfield中集成使用

现在你可以完全抛弃std::tuple的实例，改用纯类型元组来管理T...，直接通过类型访问静态成员：

template <uint32_t N>
struct BitfieldBits {
    constexpr static inline uint64_t num_bits = N;
};

struct DepthMode : BitfieldBits<2> {};
struct UseCulling : BitfieldBits<1> {};
struct VertexShaderID : BitfieldBits<8> {};

template <typename ... T>
struct MyBitfield {
    uint64_t bitfield;

    // 仅持有类型列表，无任何对象实例！
    using TypeList = TypeTuple<T...>;

    constexpr static inline std::array<uint32_t, sizeof ... (T)> bit_shift_offsets = []() consteval {
        std::array<uint32_t, sizeof ... (T)> arr;

        auto lambda = [&] <int offset, int idx>(const auto& self) consteval {
            if constexpr (idx >= sizeof ... (T)) return;
            else {
                // 直接通过类型访问静态成员，完全不需要对象！
                using CurrentType = TypeGet_t<idx, TypeList>;
                arr[idx] = offset;
                // 累加当前类型的位数，计算下一个偏移
                self.template operator()<offset + CurrentType::num_bits, idx + 1>(self);
            }
        };

        lambda.template operator()<0, 0>(lambda);
        return arr;
    }();
};

// 测试代码
int main() {
    MyBitfield<DepthMode, UseCulling, VertexShaderID> my_bitfield;
    constexpr auto offset = my_bitfield.bit_shift_offsets[2]; // 结果是2+1=3，正确！
}

为什么这个方案更优？ #

1. 完全无实例化：不会构造任何T的对象，哪怕T没有默认构造函数或者构造函数不是constexpr，代码都能正常编译
2. 类型安全：所有类型访问都是在编译期完成的，没有运行时开销
3. 灵活性高：可以扩展出更多类型操作（比如遍历所有类型、计算总位数等），比如：

// 扩展：计算所有类型的总位数
template <typename Tuple>
struct TotalBits;

template <typename... Ts>
struct TotalBits<TypeTuple<Ts...>> {
    static constexpr uint64_t value = (Ts::num_bits + ...); // 折叠表达式求和
};

// 在MyBitfield中使用
template <typename ... T>
struct MyBitfield {
    // ... 其他代码 ...
    constexpr static inline uint64_t total_bits = TotalBits<TypeList>::value; // 2+1+8=11
};

额外提示：C++20+的简化写法 #

如果你使用C++20或更高版本，还可以用模板lambda直接处理参数包的遍历，但如果需要随机索引访问类型，纯类型元组的方案依然是最清晰的选择。

内容来源于stack exchange