从函数

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;
}

DEMO

问题：

• 为什么返回的闭包对象的类型在std:is_same的第一次调用中是相同的？ （使用“普通”功能模板获得相同的结果，并且在add的正文中定义main()时也是如此。）
• 第二次调用有什么区别 - 正如我对this answer所期望的那样 - 闭包类型不同？

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;
    }

DEMO

示例输出（来自演示，使用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，它只是看起来相同，那么编译器有两个（可能）不同的表达式来编译 - 并创建不同的类型。在这里的示例输出中，例如＆＃34;主＆＃34;包含在typename中，可能是对lambda声明范围的引用。