如何实现可嵌套的可变参数函数以满足运行时Action调用需求？

核心问题分析 #

你当前代码的关键错误在于：Call函数试图将va_list直接传递给接受...（C风格可变参数）的Action函数，这属于未定义行为——...期望的是实际的可变参数序列，而非va_list对象。同时，va_list的遍历会消耗参数指针，直接传递会导致嵌套调用时参数状态混乱。

此外，原设计中依赖派生类的注册机制，也限制了系统的灵活性和嵌套能力。

可行解决方案 #

方案一：改用va_list作为Action签名，配合va_copy实现安全嵌套 #

通过统一Action的函数签名为接受va_list，结合va_copy复制参数列表，避免嵌套调用时参数被意外消耗，同时简化注册机制。

代码实现

#include <cstdarg>
#include <string>
#include <iostream>
#include <unordered_map>

// 统一Action函数签名：接受目标ID和参数列表
using ActionFunc = bool(*)(int, va_list);

// 运行时注册中心
std::unordered_map<std::string, ActionFunc> RegisteredActions;

// 注册Action
void RegisterAction(const std::string& name, ActionFunc func) {
    RegisteredActions[name] = func;
}

// 通用Call函数
bool Call(const std::string& actionName, int target, ...) {
    auto it = RegisteredActions.find(actionName);
    if (it == RegisteredActions.end()) return false;

    va_list args;
    va_start(args, target);
    
    // 复制参数列表，避免原列表被Action内部的嵌套调用修改
    va_list argsCopy;
    va_copy(argsCopy, args);
    
    bool result = it->second(target, argsCopy);
    
    va_end(argsCopy);
    va_end(args);
    
    return result;
}

// 示例Action1：输出字符串并嵌套调用另一个Action
bool PrintStringAction(int target, va_list args) {
    const char* str = va_arg(args, const char*);
    if (!str) return false; // 参数类型错误

    std::cout << "PrintStringAction (target " << target << "): " << str << "\n";
    
    // 嵌套调用CountNumbersAction
    Call("CountNumbersAction", target, 3, 10, 20, 30);

    return true;
}

// 示例Action2：输出指定数量的数字
bool CountNumbersAction(int target, va_list args) {
    int count = va_arg(args, int);
    if (count <= 0) return false;

    std::cout << "CountNumbersAction (target " << target << "): " << count << " numbers: ";
    for (int i = 0; i < count; ++i) {
        int num = va_arg(args, int);
        std::cout << num << " ";
    }
    std::cout << "\n";

    return true;
}

// 测试
int main() {
    RegisterAction("PrintStringAction", PrintStringAction);
    RegisterAction("CountNumbersAction", CountNumbersAction);

    Call("PrintStringAction", 1, "Hello Nested Actions!");
    return 0;
}

方案优势

• 改动成本低，兼容原有C风格可变参数逻辑
• 通过va_copy保证嵌套调用时参数列表独立，避免互相干扰
• 不需要派生类，注册机制更简洁

注意事项

• 必须手动检查参数的数量和类型，否则会导致未定义行为
• 仅支持POD类型和指针类型的参数传递

方案二：类型安全的参数包装系统（推荐） #

彻底抛弃C风格可变参数，改用std::any包装参数，结合模板实现类型安全的Action注册与调用，同时天然支持嵌套调用。

代码实现

#include <string>
#include <iostream>
#include <unordered_map>
#include <vector>
#include <any>
#include <typeindex>
#include <tuple>
#include <utility>

// Action参数类型校验列表
using ParamTypeList = std::vector<std::type_index>;

// 包装后的Action函数签名
using WrappedActionFunc = bool(*)(int, const std::vector<std::any>&);

// 注册项：包含包装后的函数和参数类型信息
struct ActionEntry {
    WrappedActionFunc func;
    ParamTypeList paramTypes;
};

// 运行时注册中心
std::unordered_map<std::string, ActionEntry> RegisteredActions;

// 注册Action：自动包装原始函数并记录参数类型
template<typename... Args>
void RegisterAction(const std::string& name, bool(*rawFunc)(int, Args...)) {
    // 包装原始函数为接受std::vector<std::any>的函数
    auto wrappedFunc = [rawFunc](int target, const std::vector<std::any>& args) -> bool {
        try {
            // 校验参数数量
            if (args.size() != sizeof...(Args)) return false;
            
            // 提取参数并调用原始函数
            return std::apply([target, rawFunc](const auto&... unpackedArgs) {
                return rawFunc(target, unpackedArgs...);
            }, std::make_tuple(std::any_cast<const Args&>(args[0]), ...));
        } catch (const std::bad_any_cast&) {
            return false; // 参数类型不匹配
        }
    };

    // 记录参数类型信息
    ParamTypeList types = {typeid(Args)...};
    RegisteredActions[name] = {wrappedFunc, types};
}

// 通用Call函数：自动包装参数并校验类型
template<typename... Args>
bool Call(const std::string& actionName, int target, Args&&... args) {
    auto it = RegisteredActions.find(actionName);
    if (it == RegisteredActions.end()) return false;

    // 校验参数数量和类型
    const auto& requiredTypes = it->second.paramTypes;
    if (requiredTypes.size() != sizeof...(Args)) return false;

    std::vector<std::type_index> providedTypes = {typeid(Args)...};
    if (requiredTypes != providedTypes) return false;

    // 包装参数并调用Action
    std::vector<std::any> argList = {std::forward<Args>(args)...};
    return it->second.func(target, argList);
}

// 示例Action1：输出字符串并嵌套调用
bool PrintStringAction(int target, const std::string& str) {
    std::cout << "PrintStringAction (target " << target << "): " << str << "\n";
    
    // 嵌套调用CountNumbersAction
    Call("CountNumbersAction", target, 3, 10, 20, 30);

    return true;
}

// 示例Action2：输出数字列表
bool CountNumbersAction(int target, int count, int num1, int num2, int num3) {
    std::cout << "CountNumbersAction (target " << target << "): " << count << " numbers: "
              << num1 << " " << num2 << " " << num3 << "\n";

    return true;
}

// 测试
int main() {
    RegisterAction("PrintStringAction", PrintStringAction);
    RegisterAction("CountNumbersAction", CountNumbersAction);

    Call("PrintStringAction", 1, "Hello Type-Safe Nested Actions!");
    
    // 测试错误调用：参数数量不匹配，返回false
    bool wrongCall = Call("PrintStringAction", 1, "Test", 123);
    std::cout << "Wrong call result: " << std::boolalpha << wrongCall << "\n";

    return 0;
}

方案优势

• 完全类型安全：编译时记录参数类型，运行时自动校验，避免崩溃
• 支持任意类型的参数传递（包括非POD类型）
• 嵌套调用天然安全，无需额外处理参数列表
• 错误处理清晰，参数不匹配时直接返回false

注意事项

• 需要C++17及以上标准支持（std::apply和std::any）
• 注册时需明确指定Action的参数类型，无法完全动态添加未知类型参数

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