std::map使用auto报错，JSON多类型值存储方案咨询

好问题！在处理JSON这种需要存储多类型值的场景时，std::map<std::string, std::string>确实会有局限——毕竟每次都要手动转类型，还容易出错。你尝试的std::map<std::string, auto>不行是因为C++不允许用auto作为容器的模板参数（容器的类型必须在编译期确定）。

下面是几种更优的解决方案，按推荐程度排序：

1. 使用C++17的std::variant（最推荐） #

std::variant是C++17引入的类型安全的联合体，专门用来存储一组预定义的类型，完全适配你需要存储int/std::string/float的场景。它不需要手动管理类型标记，编译期就能做类型检查，比自定义类简洁可靠得多。

示例代码：

#include <map>
#include <string>
#include <variant>
#include <iostream>
#include <type_traits>

// 先定义可存储的类型集合
using JsonValue = std::variant<int, std::string, float>;
std::map<std::string, JsonValue> myMap;

int main() {
    // 直接赋值不同类型的值，无需额外转换
    myMap["age"] = 28;
    myMap["username"] = "john_doe";
    myMap["rating"] = 4.7f;

    // 取值方式1：用std::visit统一处理不同类型
    std::visit([](const auto& val) {
        using ValType = std::decay_t<decltype(val)>;
        if constexpr (std::is_same_v<ValType, int>) {
            std::cout << "Integer: " << val << "\n";
        } else if constexpr (std::is_same_v<ValType, std::string>) {
            std::cout << "String: " << val << "\n";
        } else if constexpr (std::is_same_v<ValType, float>) {
            std::cout << "Float: " << val << "\n";
        }
    }, myMap["rating"]);

    // 取值方式2：用std::get直接获取指定类型（类型不匹配会抛出std::bad_variant_access异常）
    int userAge = std::get<int>(myMap["age"]);
    std::cout << "User age: " << userAge << "\n";

    return 0;
}

2. 旧标准（C11/C14）：使用boost::variant #

如果你的项目还在用C++17之前的标准，可以用Boost库的boost::variant，它的功能和std::variant几乎一致，代码风格也类似，是工业界常用的替代方案。

3. 优化你的自定义类实现（备选） #

如果不想依赖C++17或Boost，也可以改进你原来的自定义类设计，解决原版本的一些弊端：

• 用枚举类代替int类型标记，可读性更强
• 存储类型信息，避免重复转换
• 提供类型检查和安全取值方法，减少错误

示例代码：

#include <string>
#include <stdexcept>
#include <map>

enum class ValueType { Integer, String, Float };

class JsonValue {
private:
    ValueType m_type;
    // 用union存储不同类型（注意：C++11后union可以包含非POD类型，但需要手动管理构造/析构）
    union {
        int m_intVal;
        float m_floatVal;
        std::string m_strVal;
    };

    // 辅助函数：销毁当前值（如果是string类型）
    void destroyCurrentValue() {
        if (m_type == ValueType::String) {
            m_strVal.~basic_string();
        }
    }

public:
    // 默认构造为空字符串
    JsonValue() : m_type(ValueType::String) {
        new (&m_strVal) std::string("");
    }

    // 析构函数：清理string类型的内存
    ~JsonValue() {
        destroyCurrentValue();
    }

    // 禁用拷贝（如果需要拷贝，需手动实现拷贝构造/赋值，避免浅拷贝问题）
    JsonValue(const JsonValue&) = delete;
    JsonValue& operator=(const JsonValue&) = delete;

    // 移动构造/赋值（可选）
    JsonValue(JsonValue&& other) noexcept : m_type(other.m_type) {
        if (m_type == ValueType::String) {
            new (&m_strVal) std::string(std::move(other.m_strVal));
            other.m_type = ValueType::Integer; // 避免other析构时重复销毁
        } else if (m_type == ValueType::Integer) {
            m_intVal = other.m_intVal;
        } else {
            m_floatVal = other.m_floatVal;
        }
    }

    // 设置不同类型的值
    void setInt(int val) {
        destroyCurrentValue();
        m_type = ValueType::Integer;
        m_intVal = val;
    }

    void setString(const std::string& val) {
        destroyCurrentValue();
        m_type = ValueType::String;
        new (&m_strVal) std::string(val);
    }

    void setFloat(float val) {
        destroyCurrentValue();
        m_type = ValueType::Float;
        m_floatVal = val;
    }

    // 安全取值方法
    int getInt() const {
        if (m_type != ValueType::Integer) {
            throw std::invalid_argument("Value is not an integer");
        }
        return m_intVal;
    }

    std::string getString() const {
        if (m_type != ValueType::String) {
            throw std::invalid_argument("Value is not a string");
        }
        return m_strVal;
    }

    float getFloat() const {
        if (m_type != ValueType::Float) {
            throw std::invalid_argument("Value is not a float");
        }
        return m_floatVal;
    }

    ValueType getType() const { return m_type; }
};

// 使用示例
int main() {
    std::map<std::string, JsonValue> myMap;
    myMap["age"].setInt(30);
    myMap["name"].setString("Alice");
    myMap["score"].setFloat(89.5f);

    std::cout << "Name: " << myMap["name"].getString() << "\n";
    return 0;
}

不过这种方式需要手动管理内存和类型，容易出现错误，除非特殊情况，不推荐优先使用。

4. 使用C++17的std::any（灵活但类型安全较弱） #

std::any可以存储任意类型的值，比std::variant更灵活，但缺点是取值时必须明确知道具体类型，否则会抛出std::bad_any_cast异常，适合不确定类型范围的场景。你的场景是明确的三种类型，所以std::variant更合适。

示例代码：

#include <map>
#include <string>
#include <any>
#include <iostream>

int main() {
    std::map<std::string, std::any> myMap;
    myMap["count"] = 100;
    myMap["message"] = std::string("Hello World");
    myMap["price"] = 19.99f;

    // 取值必须指定正确类型
    try {
        int count = std::any_cast<int>(myMap["count"]);
        std::cout << "Count: " << count << "\n";
    } catch (const std::bad_any_cast& e) {
        std::cerr << "Type cast error: " << e.what() << "\n";
    }
    return 0;
}

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