如何实现C++函数为auto变量分配不同类型？自定义类问题求助

nlohmann json的auto推导示例 #

nlohmann json库支持让auto变量自动推导对应的值类型，示例代码如下：

#include <iostream>
#include "./x64/Debug/single_include/nlohmann/json.hpp"
using namespace std;

using json = nlohmann::json;

int main()
{
    nlohmann::json obj = nlohmann::json::parse("{ \"one\": \"111\", \"two\": 222}");

    string res1 = obj["one"];       // 显式类型赋值
    int res2 = obj["two"];

    auto a1 = obj["one"];           // auto自动推导类型
    auto a2 = obj["two"];

    cout << "Types defined:  " << res1 << ' ' << res2 << endl;
    cout << "Auto variables: " << a1 << ' ' << a2 << endl;
}

运行结果：

Types defined:  111 222
Auto variables: "111" 222

可以看到auto变量正确推导并获取了string和int类型的值。

自定义类的问题 #

尝试用继承+虚转换运算符实现类似功能，但auto变量无法正确推导类型，代码如下：

#include <iostream>
#include <unordered_map>
using namespace std;

class PayloadParamBase;
unordered_map<string, PayloadParamBase*> map;

class PayloadParamBase                          // 基类
{
public:
    virtual void operator= (const int i) { };
    virtual void operator= (const string s) { };

    virtual operator int() const { return 0; };     // 虚转换运算符
    virtual operator string() const { return ""; };
    
    PayloadParamBase& operator[](const char* key) { string tmp(key); return operator[](tmp); }
    PayloadParamBase& operator[](const string& key); 
};

PayloadParamBase& PayloadParamBase::operator[] (const string& key)
{
    PayloadParamBase* ptr = map[key];               // 查找派生类对象
    return *ptr;
}

class PayloadStringParam : public PayloadParamBase      // 字符串派生类
{
public:
    PayloadStringParam(string st) { mValue = st; }
    virtual operator string() const override { return mValue; }
protected:
    string  mValue;
};

class PayloadIntParam : public PayloadParamBase         // 整数派生类
{
public:
    PayloadIntParam(int i) { mValue = i; }
    virtual operator int() const override { return mValue; }
protected:
    int mValue;
};

int main()
{
    map["one"] = new PayloadStringParam("111");
    map["two"] = new PayloadIntParam(222);

    PayloadParamBase pl;

    string strVal = pl["one"];  // 显式类型赋值正常工作
    int intVal = pl["two"];
    cout << "Types defined: " << strVal << ' ' << intVal << endl;

    auto res1 = pl["one"];      // auto赋值无法获取正确类型
    auto res2 = pl["two"];
    cout << "Auto variables: " << res1 << ' ' << res2 << endl;
}

运行结果：

Types defined: 111 222
Auto variables: 0 0

问题本质 #

auto res1 = pl["one"]中，operator[]的返回值类型是编译期确定的PayloadParamBase&，所以auto会直接推导为这个基类引用类型，而不会感知到运行期实际指向的派生类对象。当你把这个引用输出到cout时，编译器会在基类的两个转换运算符中选择优先级更高的operator int()，因此输出默认的0。

核心矛盾：auto是编译期类型推导，而继承的多态是运行期行为，无法通过基类引用让auto推导到实际的派生类类型。

解决方案 #

方案1：使用std::variant存储多类型（推荐） #

放弃继承方案，改用std::variant（C++17及以上支持）来存储不同类型的值，这也是nlohmann json的核心实现思路之一。auto可以直接推导到variant的引用类型，结合std::visit可以正确处理不同类型的输出：

#include <iostream>
#include <unordered_map>
#include <variant>
#include <string>
#include <type_traits>
using namespace std;

class Payload
{
private:
    unordered_map<string, variant<int, string>> data;
public:
    // 重载[]用于取值和赋值
    variant<int, string>& operator[](const string& key)
    {
        return data[key];
    }
};

// 为std::variant重载输出运算符，模仿json格式
ostream& operator<<(ostream& os, const variant<int, string>& v)
{
    visit([&os](const auto& val) {
        if constexpr (is_same_v<decltype(val), const string&>)
        {
            os << "\"" << val << "\""; // 字符串添加引号
        }
        else
        {
            os << val;
        }
    }, v);
    return os;
}

int main()
{
    Payload pl;
    pl["one"] = string("111");
    pl["two"] = 222;

    // 显式类型转换
    string strVal = get<string>(pl["one"]);
    int intVal = get<int>(pl["two"]);
    cout << "Types defined:  " << strVal << ' ' << intVal << endl;

    // auto自动推导
    auto res1 = pl["one"];
    auto res2 = pl["two"];
    cout << "Auto variables: " << res1 << ' ' << res2 << endl;
}

运行结果与nlohmann json完全一致，auto推导的是variant<int, string>&，输出时会根据实际存储的值类型调用对应的逻辑。

方案2：使用代理类触发类型转换（兼容继承结构） #

如果坚持使用继承体系，可以设计一个代理类，让operator[]返回代理对象而非基类引用。代理类通过重载转换运算符，在运行期转发到实际对象的正确转换逻辑：

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

class PayloadParamBase;
unordered_map<string, PayloadParamBase*> map;

class PayloadParamBase
{
public:
    virtual ~PayloadParamBase() = default;
    virtual operator int() const = 0;
    virtual operator string() const = 0;
    virtual void print(ostream& os) const = 0; // 新增虚打印函数
};

class PayloadStringParam : public PayloadParamBase
{
public:
    PayloadStringParam(string st) : mValue(std::move(st)) {}
    operator int() const override { return stoi(mValue); }
    operator string() const override { return mValue; }
    void print(ostream& os) const override { os << "\"" << mValue << "\""; }
private:
    string mValue;
};

class PayloadIntParam : public PayloadParamBase
{
public:
    PayloadIntParam(int i) : mValue(i) {}
    operator int() const override { return mValue; }
    operator string() const override { return to_string(mValue); }
    void print(ostream& os) const override { os << mValue; }
private:
    int mValue;
};

// 代理类
class PayloadProxy
{
private:
    PayloadParamBase* ptr;
public:
    PayloadProxy(PayloadParamBase* p) : ptr(p) {}

    // 重载转换运算符，转发到实际对象
    operator int() const { return *ptr; }
    operator string() const { return *ptr; }

    // 重载输出运算符，调用虚打印函数
    friend ostream& operator<<(ostream& os, const PayloadProxy& proxy)
    {
        proxy.ptr->print(os);
        return os;
    }
};

class Payload
{
public:
    PayloadProxy operator[](const string& key)
    {
        return PayloadProxy(map[key]);
    }
};

int main()
{
    map["one"] = new PayloadStringParam("111");
    map["two"] = new PayloadIntParam(222);

    Payload pl;

    string strVal = pl["one"];
    int intVal = pl["two"];
    cout << "Types defined:  " << strVal << ' ' << intVal << endl;

    auto res1 = pl["one"];
    auto res2 = pl["two"];
    cout << "Auto variables: " << res1 << ' ' << res2 << endl;

    // 释放内存
    delete map["one"];
    delete map["two"];
}

这个方案中，auto推导的是PayloadProxy类型，输出时会调用实际对象的虚print函数，从而得到正确的结果。

关键总结 #

• 继承多态是运行期行为，无法直接让编译期的auto推导到派生类类型；
• 推荐使用std::variant实现类型安全的多类型存储，更符合现代C++的设计思路；
• 代理类方案可以兼容现有继承结构，但需要额外处理类型转发逻辑。

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