函数返回的lambda闭包的C++类型

Question

请看以下示例代码：

考虑以下示例代码：

int main()
{
    auto id = []()
    {
        auto ret = [](auto u) { return u; };
        return ret;
    };

    //same closure type -- prints '1'
    auto f1 = id();
    auto g1 = id();
    std::cout<<std::is_same<decltype(f1), decltype(g1)>::value<<std::endl;

    //differenct closure type -- prints '0'
    auto f2 = [](auto u) { return u; };
    auto g2 = [](auto u) { return u; };    
    std::cout<<std::is_same<decltype(f2), decltype(g2)>::value<<std::endl;
}

演示

问题：

• 为什么第一次调用 std::is_same 返回的闭包对象类型相同？（使用“普通”函数模板也可以得到相同的结果，而且当 add 在 main() 函数体内定义时也是如此。）
• 与第二次调用有何不同，第二次调用中 -- 如我从这个答案所期望的那样 -- 闭包类型不同？

- davidhigh

---

好的，你正在调用add的相同特化版本的operator()... - Columbo

在“auto f2 = [t{3}](auto u) { return t + u; };”中，t是什么？ - Humam Helfawi

@Columbo: 我预期当调用add的operator()时，在函数内部会生成一个新的具有唯一类型的闭包，并在此之后返回--就像在主函数中发生的那样。这个期望有什么问题吗？ - davidhigh

如果在运行时提供循环边界并在循环中调用lambda add，会发生什么？编译器如何为每次循环生成唯一的lambda类型？请注意，所有情况下与add一起使用的类型都是int，如示例所示（请参见初始帖子）。 - Niall

@Niall：我明白了这个例子，谢谢。你说得对，这很自然：具有给定参数的成员函数具有唯一的返回类型，而不是每次调用都有一个新类型。 - davidhigh

Answer 1

我稍微扩展了您（未编辑的）示例，以获得更多信息：

#include<iostream>
#include<type_traits>
#include<utility>
#include<functional>
#include<array>
#include<tuple>
#include<algorithm>
#include<string>


    auto add = [](auto t)
    {
        auto ret = [t](auto u) { return t + u; };
        return ret;
    };

    int main()
    {    
        //same closure type -- prints '1'
        auto f1 = add(3);
        auto g1 = add(4);
        auto h1 = add(1.);
        std::cout<<std::is_same<decltype(f1), decltype(g1)>::value<<std::endl;
        std::cout<<std::is_same<decltype(f1), decltype(h1)>::value<<std::endl;
        std::cout<<typeid(f1).name() <<"\t" << typeid(g1).name()<<"\t" << typeid(h1).name()<<std::endl;

        //differenct closure type -- prints '0'
        auto f2 = [t{3}](auto u) { return t + u; };
        auto g2 = [t{4}](auto u) { return t + u; };    
        std::cout<<std::is_same<decltype(f2), decltype(g2)>::value<<std::endl;
        std::cout<<typeid(f2).name() << "\t" << typeid(g2).name()<<std::endl;

        //using same line multiple times
        std::vector<std::string> types;
        for(int i=0; i<3; ++i)
            types.push_back(typeid([t{i}](auto u) { return t + u;     }).name());

        for(auto type:types)
            std::cout<<type<<std::endl;
    }

演示

示例输出（来自演示，使用g++）：

1
0
ZNKUlT_E_clIiEEDaS_EUlS_E_  ZNKUlT_E_clIiEEDaS_EUlS_E_  ZNKUlT_E_clIdEEDaS_EUlS_E_
0
Z4mainEUlT_E_   Z4mainEUlT_E0_
Z4mainEUlT_E1_
Z4mainEUlT_E1_
Z4mainEUlT_E1_

对我来说，这看起来是这样的：
正如您链接的答案所述，每个lambda都有自己的类型。
然而add()函数被视为模板，因此每种类型都有一个专门化版本（例如int和float）。由于您只调用了这个函数两次（对于int部分），因此相同的代码将执行两次 - 在像C++这样的强类型语言中，这当然会生成相同的类型。如果在循环中调用，则会发生相同的情况。
但是，如果声明了一个看起来相同的lambda，则编译器需要编译两个（可能）不同的表达式 - 并创建不同的类型。在此示例输出中，例如包含“main”在类型名称中，可能是对声明lambda的作用域的某些引用。

- Anedar