假设相同的 lambda 表达式具有不同的类型是否安全？

Question

我正在试验 lambdas 以及不同的 lambda 表达式具有不同类型的事实，即使它们是相同的。考虑这段代码

#include <iostream>

template <typename T> void once(T t){
    static bool first_call = true;
    if (first_call) t();
    first_call = false;
}

int main() {    
    int counter = 0;
    auto a = [&counter](){counter++;};
    once(a);
    once(a);
    std::cout << counter;              // 1

    auto b = a;                        // same type
    once(b);
    std::cout << counter;              // 1

    auto c = [&counter](){counter++;}; // different type
    once(c);
    once(c);               
    std::cout << counter;              // 2
}

这打印出112，即a 和b 当然是同一种类型而c 有不同的类型。

是否允许编译器让c 与a 属于同一类型？

我的意思是表达式是相同的，这将是一个明显的优化。

PS：如果捕获阻止了这种优化，那么没有捕获的 lambdas 呢？

相关：what is the type signature of a c++11/1y lambda function? 和 Can the 'type' of a lambda expression be expressed?

Answer 1

是否允许编译器让c 与a 属于同一类型？

没有。 [&counter](){counter++;} 是一个 lambda 表达式，根据 [expr.prim.lambda.closure]/1：

lambda 表达式的类型（也是闭包对象的类型）是唯一的、未命名的非联合类类型，称为闭包类型，其属性如下所述。

因此，对于每个 lambda 表达式，即使它与前一个相同，您也会得到一个唯一的类型。

您可以使用typeid 来检查是否是这种情况，例如：

#include <iostream>
#include <typeinfo>

template <typename T> void once(T t){
    static bool first_call = true;
    std::cout << typeid(t).name() << std::endl;
    if (first_call) {
        t();
    }
    first_call = false;
}

int main() {    
    int counter = 0;
    auto a = [&counter](){counter++;};
    once(a);
    once(a);
    std::cout << counter << std::endl; // 1

    auto b = a;                        // same type
    once(b);
    std::cout << counter << std::endl; // 1

    auto c = [&counter](){counter++;}; // different type
    once(c);
    once(c);               
    std::cout << counter << std::endl; // 2
}

结果：

Z4mainEUlvE_                                                                                                          
Z4mainEUlvE_                                                                                                          
1                                                                                                                     
Z4mainEUlvE_                                                                                                          
1                                                                                                                     
Z4mainEUlvE0_                                                                                                         
Z4mainEUlvE0_                                                                                                         
2

你可以看到有两个函数模板实例化。