如何在C++中以编程方式为类/结构体属性赋值？

C++是静态类型语言，没有Python中setattr那种动态给对象属性赋值的原生方法，但可以通过以下几种方案实现类似功能，同时保持输入文件格式和Python版本一致：

方案一：基于函数映射表的类型安全赋值 #

核心思路是把参数名和对应的属性赋值逻辑绑定到一个映射表中，遍历解析后的INITIAL_VALUES时，调用对应逻辑完成赋值。

示例代码 #

#include <unordered_map>
#include <string>
#include <any>
#include <stdexcept>

// 定义参数结构体，和Python中的Parameters类对应
struct Parameters {
    int max_iter;
    double learning_rate;
    std::string model_name;
};

int main() {
    // 模拟解析输入文件得到的INITIAL_VALUES（键为参数名，值为任意类型）
    std::unordered_map<std::string, std::any> initial_values = {
        {"max_iter", 100},
        {"learning_rate", 0.01},
        {"model_name", std::string("linear_regression")}
    };

    // 构建参数名到赋值函数的映射，对应Python中的DEST_DICT_PARAMS
    std::unordered_map<std::string, std::function<void(Parameters&, const std::any&)>> dest_dict = {
        {"max_iter", [](Parameters& p, const std::any& val) {
            if (val.type().hash_code() != typeid(int).hash_code()) {
                throw std::invalid_argument("max_iter expects int type");
            }
            p.max_iter = std::any_cast<int>(val);
        }},
        {"learning_rate", [](Parameters& p, const std::any& val) {
            if (val.type().hash_code() != typeid(double).hash_code()) {
                throw std::invalid_argument("learning_rate expects double type");
            }
            p.learning_rate = std::any_cast<double>(val);
        }},
        {"model_name", [](Parameters& p, const std::any& val) {
            if (val.type().hash_code() != typeid(std::string).hash_code()) {
                throw std::invalid_argument("model_name expects string type");
            }
            p.model_name = std::any_cast<std::string>(val);
        }}
    };

    // 完成属性赋值
    Parameters params;
    for (const auto& [key, val] : initial_values) {
        auto it = dest_dict.find(key);
        if (it != dest_dict.end()) {
            try {
                it->second(params, val);
            } catch (const std::bad_any_cast& e) {
                throw std::runtime_error("Failed to assign parameter " + key + ": " + e.what());
            }
        } else {
            throw std::runtime_error("Unknown parameter: " + key);
        }
    }

    return 0;
}

方案二：用std::variant限定值类型（C++17+） #

如果输入参数的类型是固定的几种，可以用std::variant替代std::any，避免类型转换的额外开销，同时增强类型安全性。

示例代码 #

#include <unordered_map>
#include <string>
#include <variant>
#include <stdexcept>

struct Parameters {
    int max_iter;
    double learning_rate;
    std::string model_name;
};

// 限定参数值的允许类型
using ParamValue = std::variant<int, double, std::string>;

int main() {
    std::unordered_map<std::string, ParamValue> initial_values = {
        {"max_iter", 100},
        {"learning_rate", 0.01},
        {"model_name", std::string("linear_regression")}
    };

    std::unordered_map<std::string, std::function<void(Parameters&, const ParamValue&)>> dest_dict = {
        {"max_iter", [](Parameters& p, const ParamValue& val) {
            if (std::holds_alternative<int>(val)) {
                p.max_iter = std::get<int>(val);
            } else {
                throw std::invalid_argument("max_iter must be int");
            }
        }},
        {"learning_rate", [](Parameters& p, const ParamValue& val) {
            if (std::holds_alternative<double>(val)) {
                p.learning_rate = std::get<double>(val);
            } else {
                throw std::invalid_argument("learning_rate must be double");
            }
        }},
        {"model_name", [](Parameters& p, const ParamValue& val) {
            if (std::holds_alternative<std::string>(val)) {
                p.model_name = std::get<std::string>(val);
            } else {
                throw std::invalid_argument("model_name must be string");
            }
        }}
    };

    Parameters params;
    for (const auto& [key, val] : initial_values) {
        auto it = dest_dict.find(key);
        if (it != dest_dict.end()) {
            it->second(params, val);
        } else {
            throw std::runtime_error("Unknown parameter: " + key);
        }
    }

    return 0;
}

注意事项 #

• 类型校验：C++是强类型语言，必须确保输入值的类型和结构体成员类型匹配，否则会抛出异常，建议在解析输入或赋值阶段添加类型校验逻辑。
• 兼容性：两种方案都基于C标准库，无需额外第三方依赖，方案二需要C17及以上版本支持。
• 输入格式一致性：解析输入文件时，只需将内容转换为std::unordered_map<std::string, std::any>或std::unordered_map<std::string, ParamValue>，即可和Python版本的输入格式完全对齐。

内容的提问来源于stack exchange，提问作者Ryne C Johnston