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表达式的上下文,包括其捕获的变量、参数类型等。在这个阶段,编译器决定生成一个匿名类来表示这个Lambda表达式,并且确定该类的
-
类型推导和类生成:
- 编译器根据Lambda表达式的结构生成一个匿名类,这个类带有捕获的变量(如果有)和
operator()
成员函数。这个匿名类是编译器生成的,不需要开发者明确地定义。该类通常没有名称,因此只能通过类型推导来引用。 - 如果Lambda表达式不捕获任何变量,那么它可能是一个轻量级的结构体类,只有一个
operator()
方法。
- 编译器根据Lambda表达式的结构生成一个匿名类,这个类带有捕获的变量(如果有)和
-
代码生成:
- 在代码生成阶段,编译器将Lambda表达式的实例化替换为匿名类的构造函数调用。即编译器生成代码时,会把Lambda表达式替换为对这个匿名类构造函数的调用,例如
MyLambda()
。 - 这时,编译器还会生成
operator()
函数的代码,确保在调用func(component)
时实际调用的是匿名类的operator()
方法。
- 在代码生成阶段,编译器将Lambda表达式的实例化替换为匿名类的构造函数调用。即编译器生成代码时,会把Lambda表达式替换为对这个匿名类构造函数的调用,例如
链接阶段:
- 在编译完成后,链接阶段将生成的目标代码和其他模块(如库、其他目标文件)链接在一起,生成可执行文件或库文件。在这个阶段,与Lambda表达式相关的代码已经完全转化为匿名类及其方法的调用,不再有Lambda表达式的影子。