为什么这些函数不会衰减到函数指针？

Question

我有一个类，其中包含一个要调用的函数指针，现在我遇到了一种情况，我希望该可调用函数保存一个自包含的引用/值（lambda）。因此，我创建了模板化类，以接受函数指针或lambda：

template <typename FunctionType>
class MyClass
{
public:
    MyClass(FunctionType function) : function(function) {}
    FunctionType function;
};
但是似乎每次每次实例化此类时，编译器都会创建一个不同的类类型，如下所示：

int main()
{
    MyClass foo([]() {return 5; });
    MyClass foo2([]() {return 5; });
    MyClass foo3([]() {return 5; }); // ALL THREE OF THESE SEEM TO BE DIFFERENT TYPES
    MyClass foo4(static_cast<int(*)()> ([]() {return 5; })); // I THINK I CAN FORCE THEM TO BE THE SAME TYPES BY CASTING
    MyClass foo5(static_cast<int(*)()> ([]() {return 5; }));
    MyClass foo6(static_cast<int(*)()> ([]() {return 5; }));

    std::cout << typeid(foo).name() << '\n';
    std::cout << typeid(foo2).name() << '\n';
    std::cout << typeid(foo3).name() << '\n';
    std::cout << typeid(foo4).name() << '\n';
    std::cout << typeid(foo5).name() << '\n';
    std::cout << typeid(foo6).name() << '\n';
}
此输出为：

class MyClass<class <lambda_e39b14fd1b959adc3c33a259b5258211> >
class MyClass<class <lambda_de164f9f0bca248459ade49332a364c3> >
class MyClass<class <lambda_9fcf071b66983e924cb117ca1e77c4c6> >
class MyClass<int (__cdecl*)(void)>
class MyClass<int (__cdecl*)(void)>
class MyClass<int (__cdecl*)(void)>
由于我将创建数百或数千个，所以我希望尽可能不要出现这种情况。除了偶尔需要的不同的lambda外，传递给我的类的大多数函数应具有相同的类型。那么，每当我传递相同的函数类型时，编译器是否会创建不同的类型？如果是这样的话，似乎效率不是很高。如果必须这样做，减少编译器创建的类类型数量的最佳方法是什么？我想我是通过在创建类时强制转换为函数指针来实现的，但这似乎是一种糟糕的方法。

我有一个类，其中包含一个要调用的函数指针，现在我遇到了一种情况，我希望该可调用函数保存一个自包含的引用/值（lambda）。所以我创建了...

Answer 1

您可以使您的类改为存储函数指针，如下所示：