探究C++20可变参数捕获等价实现：cppinsight输出是否合法？

背景与测试代码 #

出于好奇，在观看C++ weekly ep 171后，我想要探究C++20可变参数捕获的实现方式，于是用cppinsight工具做了分析。测试代码如下：

#include <utility>

template <typename C, typename... A>
auto bind_values(C callable, A... args) {
    return [callable = std::move(callable), ... my_param = std::move(args)]() {
        return callable(my_param...);
    };
}

int add(int lhs, int rhs) { return lhs + rhs; }

int main() {
    const auto bound = bind_values(add, 1, 2);
    return bound();
}

cppinsight生成的相关输出 #

cppinsight输出的核心部分如下：

class __lambda_6_12
{
public: 
    inline auto operator()() const
    {
        return callable(my_param... );
    }
    
private: 
    auto callable;
    auto... my_param;
    
public:
    __lambda_6_12(auto _callable, auto const &... _my_param)
        : callable{_callable}
        , my_param{_my_param...}
    {}
    
} __lambda_6_12{std::move(callable), std::move(args)};

疑问与个人尝试 #

我对这段输出里成员变量用auto甚至auto...声明感到惊讶，原本以为编译器会用tuple来打包参数。我想知道这是cppinsight生成的伪代码，还是合法的C++语法？我倾向于前者，因为这段代码无法编译，逻辑上也说不通。

我自己尝试手动实现了类似的闭包类：

#include <tuple>
template <typename C, typename... A>
class __lambda_6_12 {
public:
    inline auto operator()() const { return callable(my_param...); }

private:
    C callable;
    std::tuple<A...> my_param;

public:
    __lambda_6_12(C _callable, A const &..._my_param)
        : callable{_callable}, my_param{_my_param...} {}
};

这个实现看起来更符合编译器的要求，但注意其中的operator()存在错误，需要先把tuple展开成参数包，再传递给callable。

核心结论 #

cppinsight输出的是伪代码，并非合法的标准C++语法。

为什么cppinsight会这么输出？ #

cppinsight的设计目标是用更直观的方式展示编译器对C++代码的实际处理逻辑，而非产出可编译的代码。它用auto成员和auto...参数包成员，是为了简化展示lambda闭包的实际结构——底层编译器生成的闭包类，确实会为每个捕获的可变参数创建独立的成员变量，而非打包成tuple。这种写法是cppinsight的简化表达，方便开发者快速理解闭包的组成，不能直接用于编译。

标准C++中可变参数捕获的实际实现 #

当你在C++20中使用... my_param = std::move(args)这种可变参数捕获时，编译器生成的闭包类会为参数包args中的每个元素创建一个独立的成员变量，类型对应每个实参的具体类型。比如你传入1和2，闭包类会生成两个int类型的成员，而不是一个tuple<int, int>。

修正手动实现的错误 #

你手动实现的tuple版本，需要修正operator()才能正常工作，可以用std::apply来展开tuple：

#include <tuple>
#include <utility> // 需包含此头文件用于std::apply

template <typename C, typename... A>
class __lambda_6_12 {
public:
    inline auto operator()() const {
        return std::apply(callable, my_param);
    }

private:
    C callable;
    std::tuple<A...> my_param;

public:
    __lambda_6_12(C _callable, A const &..._my_param)
        : callable{_callable}, my_param{_my_param...} {}
};

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