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

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()的主体中定义时也是如此。)
• 第二个调用有什么不同--正如我从这个答案中所期望的--闭包类型是不同的？

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()-function被视为模板，因此对每种类型都有一个专门化(在我的示例int和-function中)。因为您只调用这个函数两次(对于int部分)，相同的代码会执行两次--在强类型语言(如c++ )中，这当然会生成两次相同的类型。如果在循环中调用，也会发生同样的情况。

但是，如果声明了lambda，则编译器有两个(可能)不同的表达式要编译--并创建不同的类型。在这里的示例输出中，typename中包含了例如"main“，可能是对lambda声明的作用域的一些引用。