C++lambda表达式的类型

运算符重载

参考：https://en.cppreference.com/w/cpp/language/operators

如上参考链接，运算符重载大致有这样几种：

其中 operator type 有些特殊，涉及到转换函数，不需要加 return type，见下。

转换函数

见我的笔记：https://blog.csdn.net/weixin_47652005/article/details/118856689

简单测试例子：

#include <iostream>

class Conv2int
{
public:
	operator int() const
	{
		return 10;
	}
};

int main()
{
	Conv2int my_int;
	std::cout << my_int * 5 << std::endl;
}

不带 captures 的 lambda

通过网站：https://cppinsights.io/

简单的测试：

#include <iostream>

int main()
{
 	auto f = [](int a){std::cout << a << std::endl; return a;};
}

结果：

#include <iostream>

int main()
{
    
  class __lambda_5_12
  {
    public: 
    inline /*constexpr */ int operator()(int a) const
    {
      std::cout.operator<<(a).operator<<(std::endl);
      return a;
    }
    
    using retType_5_12 = int (*)(int);
    inline /*constexpr */ operator retType_5_12 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline int __invoke(int a)
    {
      std::cout.operator<<(a).operator<<(std::endl);
      return a;
    }
    
    
  };
  
  __lambda_5_12 f = __lambda_5_12{};
}

可以看到，通过 operator type 的方式，可以将这个类给转换成一个 type ，这里的 type 就是这个函数指针。

带 captures 的 lambda

一旦加了capture，就不像刚才那样可以直接转为一个函数指针了：

#include <iostream>

int main()
{
  	int b = 0;
 	auto f = [&b](int a){std::cout << a << std::endl; return a;};
}

网站解析如下：

#include <iostream>

int main()
{
  int b = 0;
    
  class __lambda_6_12
  {
    public: 
    inline /*constexpr */ int operator()(int a) const
    {
      std::cout.operator<<(a).operator<<(std::endl);
      return a;
    }
    
    private: 
    int & b;
    
    public:
    __lambda_6_12(int & _b)
    : b{_b}
    {}
    
  };
  
  __lambda_6_12 f = __lambda_6_12{b};
}

可以看到，其变成了一个彻彻底底的仿函数。