PAYATHON 2026

如何自动将 C++ 变量与配置文件中的对应值映射?

技术老齐

可以通过构建时代码生成,满足配置文件在编译前已存在、自动生成成员,以及使用 config.id0 和 IDE 补全的要求:先用一个小工具读取配置文件,生成 C++ 头文件,再编译使用该头文件的程序。

生成器可以用 C++ 编写,只使用标准库,无须第三方依赖。配置文件需要提供字段名称和类型等信息,因为仅凭文本 123,程序无法判断它应该是整数,还是需要原样保留的字符串。

C++23 能自动完成哪些部分?

需要区分两个需求:

  • 根据配置项名称查找值,避免受行顺序影响。
  • 根据配置项名称生成 C++ 成员,以便使用点语法和编辑器补全。

std::map、std::unordered_map 可以解决第一个需求:

item0 = dict.at("id0");

读取文件时将标识符存为键,就能通过容器查找 "id0",无须知道它在文件中的哪一行。键不存在时,at() 会抛出异常;operator[] 则会插入一个默认值,可能掩盖配置缺失的问题。

要满足第二个需求,编译时必须有相应的成员声明:

struct AppConfig {
    std::string id0;
    int id1;
};

标准 C++23 没有能从任意文本文件自动生成这些成员声明的静态反射机制,也不能通过重载 operator. 把运行时的 map 键变成成员。给普通文件读取代码加上 constexpr,也不会让它变成编译期文件读取。因此,需要在编译器处理源码之前生成这些声明。

第一步:让配置文件包含类型信息

可以约定 config.txt 每行使用以下格式:

类型 标识符 值

例如:

string id0 value0
int id1 42
int id2 100

这里的类型名称属于自定义文件格式,由生成器将 string 转换为 std::string。

示例使用以下规则:

  • 支持 string 和 int。
  • 忽略空行,以及第一个非空白字符为 # 的整行注释。
  • 字符串取标识符之后、跳过前导空白的剩余行内容,不需要引号,也不解释 \n 等转义。
  • 整数必须是完整的十进制整数文本,不能包含尾随空格或注释。
  • 标识符以 ASCII 字母开头,后续允许使用字母、数字和下划线。

如果必须保留原有的两列 id value 格式,可以把类型放在单独的字段定义文件中,但仍需明确类型信息的来源。

第二步:用 C++ 生成头文件

configgen.cpp 读取配置,检查重复名称和整数格式,然后生成带有初始值的结构体:

#include <charconv>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <system_error>
#include <unordered_set>

// 将字符串转换成 C++ 字符串字面量。
// 非 ASCII 字节使用固定三位八进制转义,保留原始字节。
std::string cpp_literal(const std::string& text) {
    std::string result = "\"";
    constexpr char oct[] = "01234567";

    for (unsigned char c : text) {
        if (c == '"' || c == '\\') {
            result += '\\';
            result += static_cast<char>(c);
        } else if (c >= 32 && c <= 126) {
            result += static_cast<char>(c);
        } else {
            result += '\\';
            result += oct[(c >> 6) & 7];
            result += oct[(c >> 3) & 7];
            result += oct[c & 7];
        }
    }

    result += '"';
    return result;
}

int main(int argc, char* argv[]) {
    try {
        if (argc != 3) {
            throw std::runtime_error(
                "usage: configgen input.txt output.hpp");
        }

        std::ifstream input(argv[1]);
        if (!input) {
            throw std::runtime_error("cannot open input file");
        }

        const std::regex identifier("[A-Za-z][A-Za-z0-9_]*");
        std::unordered_set<std::string> names;
        std::ostringstream generated;

        generated << "#ifndef APP_GENERATED_CONFIG_HPP\n"
                     "#define APP_GENERATED_CONFIG_HPP\n"
                     "#include <string>\n\n"
                     "struct AppConfig {\n";

        std::string line;
        std::size_t line_number = 0;

        while (std::getline(input, line)) {
            ++line_number;

            // 接受采用 CRLF 换行的配置文件。
            if (!line.empty() && line.back() == '\r') {
                line.pop_back();
            }

            auto fail = [&](const std::string& message) {
                throw std::runtime_error(
                    "line " + std::to_string(line_number)
                    + ": " + message);
            };

            std::istringstream row(line);
            std::string type, name, value;

            if (!(row >> type) || type.front() == '#') {
                continue;
            }
            if (!(row >> name)) {
                fail("missing identifier");
            }

            if (!std::regex_match(name, identifier)
                || name.find("__") != std::string::npos
                || name == "AppConfig") {
                fail("invalid identifier: " + name);
            }
            if (!names.insert(name).second) {
                fail("duplicate identifier: " + name);
            }

            std::getline(row >> std::ws, value);

            if (type == "string") {
                generated << "    std::string " << name << '{'
                          << cpp_literal(value) << ", "
                          << value.size() << "};\n";
            } else if (type == "int") {
                int number{};
                const char* begin = value.data();
                const char* end = begin + value.size();

                const auto [ptr, ec] =
                    std::from_chars(begin, end, number);

                if (ec != std::errc{} || ptr != end) {
                    fail("invalid int for " + name);
                }

                generated << "    int " << name
                          << " = " << number << ";\n";
            } else {
                fail("unsupported type: " + type);
            }
        }

        if (input.bad()) {
            throw std::runtime_error("input read failed");
        }

        generated << "};\n\n#endif\n";

        // 解析成功后才打开输出文件。
        std::ofstream output(argv[2]);
        if (!output) {
            throw std::runtime_error("cannot open output file");
        }

        output << generated.str();
        output.close();
        if (!output) {
            throw std::runtime_error("output write failed");
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
        return 1;
    }
}

示例检查了标识符的字符形式,但没有列出全部 C++ 关键字。配置名称仍须避开 class、int 等关键字,否则编译器会在编译生成的头文件时报错。

前面的配置会生成以下头文件:

#ifndef APP_GENERATED_CONFIG_HPP
#define APP_GENERATED_CONFIG_HPP
#include <string>

struct AppConfig {
    std::string id0{"value0", 6};
    int id1 = 42;
    int id2 = 100;
};

#endif

生成器会填写字符串初始化时使用的长度,这样也能保留字符串中的空字节。普通配置字符串无须手动处理这个长度。

第三步:生成、编译并访问成员

使用 GCC 时,可以依次执行:

g++ -std=c++23 configgen.cpp -o configgen
./configgen config.txt generated_config.hpp
g++ -std=c++23 main.cpp -o app

每条命令都需要成功后再执行下一条。实际项目应将生成步骤加入构建系统,并把配置文件和生成器声明为生成头文件的依赖,避免配置更新后仍然编译旧头文件。

main.cpp 可以直接使用生成的成员:

#include "generated_config.hpp"

#include <iostream>

void run(const AppConfig& config) {
    std::cout << config.id0 << '\n';
    std::cout << config.id1 + config.id2 << '\n';
}

int main() {
    AppConfig config;
    run(config);
}

生成的头文件已存在,且 IDE 能正确解析项目的包含路径时,输入 config. 通常就能看到成员补全。具体效果取决于 IDE 或语言服务器,C++ 标准并不保证这项功能。

重新排列配置行后,每个值仍按同一行的标识符生成,业务代码中的访问表达式无须修改。例如,新增一行:

int retry_count 3

重新生成并编译后,就能访问:

config.retry_count

如果访问已删除的成员,或拼错成员名,例如写成 config.retry_cout,编译器会报错。

如果希望程序启动时读取配置

这个实现将值写进了生成的头文件。即使只修改已有字段的值,也需要重新生成并编译,程序运行时不会再读取 config.txt。这符合题目给出的更新方式。

如果以后希望修改数值后只重启程序,可以调整生成器,让它生成:

  1. AppConfig 的成员声明。
  2. 根据键名赋值的加载代码。

例如,生成的加载代码可以包含:

config.id0 = values.at("id0");
config.id1 = parse_int(values.at("id1"));
config.id2 = parse_int(values.at("id2"));

其中,parse_int 需要自行实现,可以沿用前面基于 std::from_chars 的完整解析检查。加载器还应明确处理缺失字段、未知字段和重复字段。

工具负责生成这些赋值语句,业务代码仍然使用 config.id0。改变字段集合或类型时需要重新编译;修改已有字段的值,则可以在下次加载时生效。

如何用于多个源文件和其他程序

变量分布在不同的 .cpp 文件中时,可以让相关函数接收同一个配置对象,加载器无须逐个查找那些变量:

void initialize_network(const AppConfig& config);
void initialize_storage(const AppConfig& config);

这样也能减少配置值的重复保存。下面的赋值会创建副本:

int retry_count = config.retry_count;

之后修改 config.retry_count,副本不会自动更新。

同一个生成器也可以用于其他程序,只要它们遵守相同的文件格式和类型规则。需要支持 bool、浮点数或数组时,可以增加相应的解析和生成规则。

如果文件标识符与成员名不同,例如文件使用 server-port,代码希望使用 server_port,就需要明确名称转换规则,并检查转换后的名称是否冲突。如果要把文件中的 id0 赋给现有代码中的 item0,则需要通过字段定义或其他元数据说明这种对应关系,工具无法仅凭名称可靠推断。

备注:内容仅供参考。