C++中如何便捷模拟局部函数？避免频繁传递局部变量

问题场景 #

现有如下C++代码：

struct S final
{
   int i = 123;
   // ... 大量遗留代码 ...
   void f()
   {
      // ... 大量遗留代码 ...
      double d = 1.23;
      // ... 大量遗留代码 ...
      g(d);
      // ... 大量遗留代码 ...
   }
   // ... 大量遗留代码 ...
   void g(double& d)
   {
      i = 456; d = 4.56;
   }
};

当前实现可正常运行，但随着f()中需要传递给g()的局部变量增多，逐个传参的方式会变得异常繁琐。我们希望找到一种无需移动g()核心代码的简便方式，模拟局部函数的效果，避免频繁修改函数参数列表。

常规的lambda方案需要将g()的代码移入f()内部，不符合需求；而尝试嵌套定义函数、先声明lambda再补全函数体的写法均为无效C语法（C不支持函数嵌套，lambda必须在定义时给出完整函数体）。

可行解决方案 #

方案1：将局部变量打包为结构体（推荐） #

把f()中需要传递给g()的局部变量统一打包到一个结构体中，g()只需接收该结构体的引用即可。这种方式无需大幅修改原有代码，扩展性极强，后续新增变量仅需在结构体中添加字段，无需修改g()的函数签名。

代码示例：

struct S final
{
    int i = 123;
    // 定义用于打包f()局部变量的上下文结构体
    struct FLocalContext
    {
        double d;
        // 后续新增变量直接在此添加即可，比如：
        // int extra_int;
        // std::string extra_str;
    };

    void f()
    {
        // 初始化局部变量上下文
        FLocalContext ctx{1.23};
        // ... 原有遗留代码 ...
        g(ctx);
        // ... 原有遗留代码 ...
    }

    // g()仅需修改参数类型，核心逻辑完全保留
    void g(FLocalContext& ctx)
    {
        i = 456;
        ctx.d = 4.56;
        // 新增变量直接通过ctx访问，比如：
        // ctx.extra_int = 789;
    }
};

方案2：使用std::tuple打包（不推荐，可读性差） #

如果不想定义额外结构体，可以用std::tuple打包局部变量，但访问变量时需要通过std::get索引，可读性远不如结构体，仅适合临时快速改造：

#include <tuple>
#include <functional>

struct S final
{
    int i = 123;

    void f()
    {
        double d = 1.23;
        auto ctx = std::make_tuple(std::ref(d)); // 用std::ref传递引用
        // ... 原有代码 ...
        g(ctx);
        // ... 原有代码 ...
    }

    void g(std::tuple<std::reference_wrapper<double>>& ctx)
    {
        i = 456;
        std::get<0>(ctx) = 4.56;
    }
};

方案对比 #

• 结构体方案：可读性强、扩展性好、代码改动极小，完全符合保留原有g()代码的需求，是最优选择。
• tuple方案：无需定义结构体，但可读性差，后续维护成本高，仅适合临时场景。

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