令人头疼Lambda表示式和模板组合

1.被视为一种特殊的匿名类

Lambda表达式在C++中被视为一种特殊的匿名类，该类隐式地定义了一个operator()，使得lambda可以像函数一样被调用。当你将一个 lambda 表达式作为函数参数传递时，编译器会生成一个对应的类，其行为类似于传递一个可调用对象。这类对象通常具有 operator() 操作符，使其能够像函数一样调用。

2.把Lambda表达式作为参数传递给非模板函数

如果 lambda 表达式传递给一个普通函数（即非模板函数），编译器会为该 lambda 表达式生成一个具体类型的类，而不是模板类。这意味着 lambda 的参数类型必须在编译时确定，不能是泛型的 auto。假设这个普通函数接受的参数类型是 A，那么 lambda 表达式的编译结果会如下所示：

假设有一个普通函数的定义如下
void DrawComponent(const std::string& name, Entity entity, const MyLambda& func) 
{
    假设有后面操作 遍历entity获取其中的A类型的组件如下面传递给引用的操作
    A& component = /* 获取的A类型的组件 */;
    func(component);//调用Lambda的operator()，处理component
}

假设函数调用时具体为
DrawComponent("Box Collider 2D", entity, [](A& component) {
    ImGui::DragFloat2("Offset", glm::value_ptr(component.Offset));
    ImGui::DragFloat2("Size", glm::value_ptr(component.Size));
    ImGui::DragFloat("Density", &component.Density, 0.01f, 0.0f, 1.0f);
    ImGui::DragFloat("Friction", &component.Friction, 0.01f, 0.0f, 1.0f);
    ImGui::DragFloat("Restitution", &component.Restitution, 0.01f, 0.0f, 1.0f);
    ImGui::DragFloat("Restitution Threshold", &component.RestitutionThreshold, 0.01f, 0.0f);
});

定义中使用的func(component)中的component类型必须和函数调用时[](A& component)中的A对应
--------------
上面代码编译器是如何处理的呢？实际上会根据定义使用的参数const MyLambda& func中MyLambda
定义一个类名为MyLambda的匿名类并且携带一个使用参数类型为func(component)中componment的
类型A的operator方法.Lambda表达式基本构造为[](){}，(){}对应构造的匿名类中的函数，[]对应
捕获外部变量作为匿名类的成员变量，又因为是匿名类的成员函数，自然operator()可以使用成员变量，
对应Lambad表示中的{/..}可以使用外部变量

class MyLambda {
public:
    //operator() 是函数调用运算符，接受一个A类型的参数
    void operator()( A& component) const {
        ImGui::DragFloat2("Offset", glm::value_ptr(component.Offset));
        ImGui::DragFloat2("Size", glm::value_ptr(component.Size));
        ImGui::DragFloat("Density", &component.Density, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Friction", &component.Friction, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Restitution", &component.Restitution, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Restitution Threshold", &component.RestitutionThreshold, 0.01f, 0.0f);
    }
};


然后在函数调用的时候编译器会把MyLambda()替换掉Lambda的原表达式
DrawComponent("Box Collider 2D", entity, MyLambda());

在这个例子中，lambda 表达式被编译器生成了一个具体的 Lambda 类，该类的 operator() 方法只接受 A& 类型的参数。当 lambda 表达式传递给非模板函数 DrawComponent 时，编译器将确保 lambda 表达式的参数类型与函数调用时的参数类型匹配。因此，这种情况下，lambda 表达式的类型和参数类型都是在编译时确定的，不能再使用 auto 这种泛型类型。

2.把Lambda表达式作为参数传递给模板函数

上面提Lambda表示式传递给非模板函数时其使用的参数类型必须确定，不能是auto 这种泛型类型但是模板函数却是需要auto这种泛型类型。首先，考虑以下 lambda 表达式和模板函数：

假设有一个这样的函数定义
template<typename T, typename UIFunction>
static void DrawComponent(const std::string& name, Entity entity, UIFunction uiFunction){
    // ...
    auto& component =entity.GetComponent<T>();
    //...
    uiFunction(component); // 调用传递的 lambda
}


这是具体的函数调用传入的模板类型T为BoxCollider2DComponent
DrawComponent<BoxCollider2DComponent>("Box Collider 2D", entity, [](auto& component)
{
	ImGui::DragFloat2("Offset", glm::value_ptr(component.Offset));
	ImGui::DragFloat2("Size", glm::value_ptr(component.Size));
	ImGui::DragFloat("Density", &component.Density, 0.01f, 0.0f, 1.0f);
	ImGui::DragFloat("Friction", &component.Friction, 0.01f, 0.0f, 1.0f);
	ImGui::DragFloat("Restitution", &component.Restitution, 0.01f, 0.0f, 1.0f);
	ImGui::DragFloat("Restitution Threshold", &component.RestitutionThreshold, 0.01f, 0.0f);
});
----------------
编译器会根据函数的定义生成一个随机名字的匿名类，此时typename UIFunction模板被
替换成这个生成的匿名类的类名，同样这个类会有一个operator()的函数，这个函数使用的参数
同样根据函数定义传递给uiFunction(component)中的componment决定，不过这里的componment类型
由模板T决定，所以等于由T模板决定，所以生成的方法如下

template<typename T>
    void operator()(T& component) const {
        ImGui::DragFloat2("Offset", glm::value_ptr(component.Offset));
        ImGui::DragFloat2("Size", glm::value_ptr(component.Size));
        ImGui::DragFloat("Density", &component.Density, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Friction", &component.Friction, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Restitution", &component.Restitution, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Restitution Threshold", &component.RestitutionThreshold, 0.01f, 0.0f);
    }

3.匿名类的生成具体阶段

编译阶段：

编译阶段是指代码从源文件转换为目标代码的过程中所经历的步骤，包括语法分析、语义分析、代码生成等。在这个阶段，Lambda表达式的处理分为以下几个子阶段：

• 语法分析：

  • 编译器在语法分析阶段识别出代码中的Lambda表达式。它检查Lambda的语法是否合法，并解析它的捕获列表、参数列表、返回类型和函数体。

• 语义分析：

  • 编译器在语义分析阶段确定Lambda表达式的上下文，包括其捕获的变量、参数类型等。在这个阶段，编译器决定生成一个匿名类来表示这个Lambda表达式，并且确定该类的operator()函数的签名。

• 类型推导和类生成：

  • 编译器根据Lambda表达式的结构生成一个匿名类，这个类带有捕获的变量（如果有）和operator()成员函数。这个匿名类是编译器生成的，不需要开发者明确地定义。该类通常没有名称，因此只能通过类型推导来引用。
  • 如果Lambda表达式不捕获任何变量，那么它可能是一个轻量级的结构体类，只有一个operator()方法。

• 代码生成：

  • 在代码生成阶段，编译器将Lambda表达式的实例化替换为匿名类的构造函数调用。即编译器生成代码时，会把Lambda表达式替换为对这个匿名类构造函数的调用，例如MyLambda()。
  • 这时，编译器还会生成operator()函数的代码，确保在调用func(component)时实际调用的是匿名类的operator()方法。

链接阶段：

• 在编译完成后，链接阶段将生成的目标代码和其他模块（如库、其他目标文件）链接在一起，生成可执行文件或库文件。在这个阶段，与Lambda表达式相关的代码已经完全转化为匿名类及其方法的调用，不再有Lambda表达式的影子。