如何处理运行时确定的同质无符号整数数组存储与操作？

需要存储并处理一组无符号整数，数据类型可能是uint8_t、uint16_t或uint32_t，类型完全由运行时决定且不可控。目前使用单个std::vector<uint16_t>存储，但类型不匹配时会引发问题——比如将uint32_t*的数据直接复制到uint16_t类型的vector中会导致截断或内存越界。

现有实现的问题示例 #

当前的实现通用性极差，示例代码如下：

class DataContainer {
public:
    std::vector<uint16_t> indices;
};

switch(indexType) {
    case 1: // uint8_t
        const uint8_t* data_u8 = reinterpret_cast<const uint8_t*>(data);
        std::memcpy(indices.data(), data_u8, count * sizeof(uint8_t));
        break;
    case 2: // uint16_t
        const uint16_t* data_u16 = reinterpret_cast<const uint16_t*>(data);
        std::memcpy(indices.data(), data_u16, count * sizeof(uint16_t));
        break;
    case 4: // uint32_t
        const uint32_t* data_u32 = reinterpret_cast<const uint32_t*>(data);
        std::memcpy(indices.data(), data_u32, count * sizeof(uint32_t));
        break;
    default:
        printf("Unsupported index type %d\n", indexType);
        return false;
}

候选方案分析 #

• 使用std::variant存储不同类型的vector

  • 优点：严格保证类型安全，避免类型不匹配的内存错误。
  • 缺点：访问数据时需要使用std::visit，增加了代码复杂度；暂时无法直接调用size()或data()方法。
    示例代码：

  #include <variant>
  #include <vector>
  #include <cstdint>
  
  using IndexBuffer = std::variant<std::vector<uint8_t>, std::vector<uint16_t>, std::vector<uint32_t>>;
  
  class DataContainer {
  public:
      IndexBuffer indices;
  };
  

• 统一存储为std::vector<uint32_t>

  • 优点：操作最简单，无需处理类型分支，所有小类型直接向上转换为uint32_t。
  • 缺点：会造成不必要的内存浪费——比如存储uint8_t时，每个元素占用4倍内存。

• 为每种类型单独维护vector

  • 优点：无需类型转换，直接存储原始类型。
  • 缺点：代码冗余度极高，需要额外维护类型标记，使用时必须判断当前有效vector，扩展性差。
    示例代码：

  class DataContainer {
  public:
      std::vector<uint8_t> indices_u8;
      std::vector<uint16_t> indices_u16;
      std::vector<uint32_t> indices_u32;
  };
  

最优方案推荐及补充方案 #

优先选择**std::variant方案**，这是C++17及以后处理动态类型场景的标准、类型安全的解决方案。针对你提到的无法直接获取size()或data()的问题，可以通过封装辅助函数解决：

获取元素数量 #

size_t get_index_count(const IndexBuffer& buffer) {
    return std::visit([](const auto& vec) { return vec.size(); }, buffer);
}

获取原始数据指针 #

const void* get_index_data(const IndexBuffer& buffer) {
    return std::visit([](const auto& vec) { return static_cast<const void*>(vec.data()); }, buffer);
}

遍历元素（类型安全处理） #

template<typename Func>
void visit_indices(const IndexBuffer& buffer, Func&& func) {
    std::visit([&func](const auto& vec) {
        for (auto val : vec) {
            func(static_cast<uint32_t>(val)); // 统一转换为uint32_t处理，或根据类型自定义逻辑
        }
    }, buffer);
}

如果你的场景对内存占用极度敏感，且操作逻辑简单，**统一存储为uint32_t**也是可接受的妥协方案——毕竟内存浪费的代价远低于类型错误引发的崩溃。

第三种单独维护vector的方案，除非有特殊的历史代码兼容需求，否则不推荐，因为它会显著增加代码维护成本。

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