如何实现多数据类型健壮映射？解决C++混合类型映射初始化报错

需要将一组包含uint8_t、uint16_t、uint32_t、uint64_t类型的键值对存入std::map，实现批量遍历处理，而非逐行单独定义。原始示例数据如下：

static constexpr uint8_t data1{0x01};
static constexpr uint16_t data2{0x0002};
static constexpr uint32_t data3{0x00000003};
static constexpr uint64_t data4{0x0000000000000004};

尝试通过union定义通用类型dtypes：

union dtypes {
uint8_t i;
uint16_t j;
uint32_t k;
uint64_t l;
};

随后创建map时触发编译错误：

std::map<std::string, dtypes> mymap = {{"data1", 0x01},
                                       {"data2", 0x0002},
                                       {"data3", 0x00000003},
                                       {"data4", 0x0000000000000004}};

错误信息：

error: could not convert "'{{"data1", 0}, {"data2", 2}, and so on..' from '<brace-enclosed initializer list>' to 'std::map<std::__cxx11::basic_string<char>, dtypes>'
                        {"data4", 0x0000000000000004}};
                                                     ^
                                                     |
                                                     <brace-enclosed initializer list>

已知byte_pushback函数可将多字节无符号整数拆分为多个uint8_t存入vector，求正确实现该映射的方法。

方案1：使用std::variant（C++17及以上，推荐） #

std::variant是C++17引入的类型安全异构容器，可直接存储不同类型的值，无需手动管理类型标记：

1. 定义map的value类型并初始化map：

#include <variant>
#include <map>
#include <string>
#include <vector>
#include <cstdint>

// 定义可存储的类型集合
using DataVariant = std::variant<uint8_t, uint16_t, uint32_t, uint64_t>;

// 初始化map，显式转换类型避免歧义
std::map<std::string, DataVariant> mymap = {
    {"data1", static_cast<uint8_t>(0x01)},
    {"data2", static_cast<uint16_t>(0x0002)},
    {"data3", static_cast<uint32_t>(0x00000003)},
    {"data4", static_cast<uint64_t>(0x0000000000000004)}
};

2. 遍历处理，用std::visit自动匹配对应类型的byte_pushback重载：

// 示例实现byte_pushback的各类型重载（若已有可忽略）
void byte_pushback(std::vector<uint8_t>& vec, uint8_t val) {
    vec.push_back(val);
}

void byte_pushback(std::vector<uint8_t>& vec, uint16_t val) {
    // 小端模式拆分，可根据需求改为大端
    vec.push_back(static_cast<uint8_t>(val & 0xFF));
    vec.push_back(static_cast<uint8_t>((val >> 8) & 0xFF));
}

void byte_pushback(std::vector<uint8_t>& vec, uint32_t val) {
    vec.push_back(static_cast<uint8_t>(val & 0xFF));
    vec.push_back(static_cast<uint8_t>((val >> 8) & 0xFF));
    vec.push_back(static_cast<uint8_t>((val >> 16) & 0xFF));
    vec.push_back(static_cast<uint8_t>((val >> 24) & 0xFF));
}

void byte_pushback(std::vector<uint8_t>& vec, uint64_t val) {
    for (int i = 0; i < 8; ++i) {
        vec.push_back(static_cast<uint8_t>((val >> (8*i)) & 0xFF));
    }
}

// 遍历处理map中的值
std::vector<uint8_t> vec;
for (const auto& [key, val] : mymap) {
    std::visit([&vec](auto&& data) {
        byte_pushback(vec, data);
    }, val);
}

方案2：带类型标记的结构体（兼容C++11/14） #

若项目无法使用C++17，可自定义结构体存储值和对应的类型标记：

1. 定义类型枚举和结构体：

#include <map>
#include <string>
#include <vector>
#include <cstdint>
#include <type_traits>

// 标记存储值的类型
enum class DataType { UINT8, UINT16, UINT32, UINT64 };

struct DataHolder {
    DataType type;
    uint64_t raw_value; // 用足够大的类型统一存储所有值

    // 模板构造函数，自动推导类型并设置标记
    template<typename T>
    DataHolder(T val, typename std::enable_if<
        std::is_same<T, uint8_t>::value ||
        std::is_same<T, uint16_t>::value ||
        std::is_same<T, uint32_t>::value ||
        std::is_same<T, uint64_t>::value
    >::type* = nullptr) : raw_value(static_cast<uint64_t>(val)) {
        if (std::is_same<T, uint8_t>::value) {
            type = DataType::UINT8;
        } else if (std::is_same<T, uint16_t>::value) {
            type = DataType::UINT16;
        } else if (std::is_same<T, uint32_t>::value) {
            type = DataType::UINT32;
        } else {
            type = DataType::UINT64;
        }
    }
};

2. 初始化map并遍历处理：

std::map<std::string, DataHolder> mymap = {
    {"data1", uint8_t(0x01)},
    {"data2", uint16_t(0x0002)},
    {"data3", uint32_t(0x00000003)},
    {"data4", uint64_t(0x0000000000000004)}
};

std::vector<uint8_t> vec;
for (const auto& pair : mymap) {
    const auto& holder = pair.second;
    switch(holder.type) {
        case DataType::UINT8:
            byte_pushback(vec, static_cast<uint8_t>(holder.raw_value));
            break;
        case DataType::UINT16:
            byte_pushback(vec, static_cast<uint16_t>(holder.raw_value));
            break;
        case DataType::UINT32:
            byte_pushback(vec, static_cast<uint32_t>(holder.raw_value));
            break;
        case DataType::UINT64:
            byte_pushback(vec, static_cast<uint64_t>(holder.raw_value));
            break;
    }
}

方案3：修复原union的初始化问题（不推荐） #

原union方案报错是因为C++不允许直接用整数初始化union（需明确指定初始化的成员），且这种方式类型不安全，必须额外记录类型信息才能正确处理：

#include <map>
#include <string>
#include <cstdint>

union dtypes {
    uint8_t i;
    uint16_t j;
    uint32_t k;
    uint64_t l;

    // 为每个类型提供构造函数
    dtypes(uint8_t val) : i(val) {}
    dtypes(uint16_t val) : j(val) {}
    dtypes(uint32_t val) : k(val) {}
    dtypes(uint64_t val) : l(val) {}
};

// 初始化map时需显式构造union实例
std::map<std::string, dtypes> mymap = {
    {"data1", dtypes(uint8_t(0x01))},
    {"data2", dtypes(uint16_t(0x0002))},
    {"data3", dtypes(uint32_t(0x00000003))},
    {"data4", dtypes(uint64_t(0x0000000000000004))}
};

⚠️ 注意：这种方式无法直接判断union中存储的是哪个类型，必须额外维护类型标记（如和方案2结合），否则调用byte_pushback时会传递错误的类型，导致数据错误。

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