Lambda 表达式的运行原理包括以下关键步骤：

1. Lambda 表达式被编译器转化为一个匿名函数对象。
2. 如果在捕获列表中指定了变量，编译器会为该匿名函数对象生成一个特殊的数据成员，以便在运行时捕获和使用这些变量的值。
3. Lambda 表达式内的代码被编译成与普通函数相似的代码，可以在需要的地方调用该函数对象。
4. 在运行时，Lambda 表达式内的捕获变量的值将与函数对象一起传递，以便在 Lambda 主体内使用。

例如

//例子一
auto lambda = [](int x, int y) -> int {
    return x + y;
};
//编译器将创建一个匿名的函数对象类伪代码：
class __lambda_function {
public:
    int operator()(int x, int y) const {
        return x + y;
    }

private:
    // 捕获的变量（如果有的话）
};

这个`__lambda_function`类中有一个`operator()`成员函数，它执行Lambda表达式内部的代码。变量`lambda`实际上是一个对象，可以像函数一样调用，例如：
int result = lambda(3, 4); // 调用Lambda表达式，result将包含7
在运行时，Lambda表达式内的代码将由这个匿名函数对象执行，并且如果有捕获的外部变量，它们也将在这个函数对象内进行管理。

//例子二：
int x = 10;
auto lambda = [x](int a) {
    return x + a;
};
//编译器将创建一个匿名的函数对象类伪代码：
class LambdaFunction {
private:
    int captured_x; // 存储捕获的变量 x
public:
    LambdaFunction(int x) : captured_x(x) {}

    int operator()(int a) const {
        return captured_x + a;
    }
};

对函数指针和指针函数补充：

函数指针 vs 指针函数：
函数指针是一个指向函数的指针变量。
指针函数是一个返回函数指针的函数。
用途：
函数指针用于存储函数的地址以便在运行时调用它。
指针函数用于根据条件返回不同的函数指针，允许在运行时选择要调用的函数。

函数指针：
函数指针是指向函数的指针变量。它存储了函数的地址，允许您在运行时动态选择要调用的函数。函数指针通常用于实现回调函数、构建函数表、创建通用代码等情况。

指针函数：
指针函数是一个返回指针的函数。它是一个函数，其返回类型是指针，该指针可以指向某种类型的数据。指针函数用于创建并返回指向某个数据对象的指针。

//函数指针：
int add(int a, int b) {
    return a + b;
}
int subtract(int a, int b) {
    return a - b;
}
int (*funcPtr)(int, int);
funcPtr = add; // 将函数指针设置为指向add函数
//funcPtr = subtract;
int result = funcPtr(5, 3); // 调用add函数，result将包含8

//指针函数：
例子一：
// 声明一个指针函数，返回类型是指向整数的指针
int* createIntPointer(int value) {
    int* ptr = new int(value);
    return ptr;
}

// 使用指针函数创建指针对象
int* pointer = createIntPointer(42);
例子二：
int* test(int a, int b) {
    int c = a + b;
    return &c;
}
int main() {
    int* testvalue =test(2,3);
    std::cout << *testvalue;//5
}

//综合例子：
#include <iostream>
// 函数指针：接受两个整数参数并返回整数
int (*add)(int, int);

// 指针函数：返回指向整数的指针
int* createIntPointer(int value) {
    int* ptr = new int(value);
    return ptr;
}

// 函数：计算两个整数的和
int sum(int a, int b) {
    return a + b;
}

int main() {
    // 分配一个整数对象并返回其指针
    int* pointer = createIntPointer(42);
    // 将函数的地址分配给函数指针
    add = &sum;   
    // 使用函数指针调用函数
    int result = add(3, 5);
    std::cout << "Result of add(3, 5): " << result << std::endl;
    std::cout << "Pointer value: " << *pointer << std::endl;
    // 释放动态分配的内存
    delete pointer; 
    return 0;
}

我cao,莫名觉得有点~昂。
永远的新手，请多多指教喽


//结合上面 自己写个Demo,运行就知道了
内容参考：https://www.zhihu.com/question/41940148
int  m = 5;	
auto f = [](int x)->int { return x; };      //准函数lambda表达式
int (*p)(int) = f;  //函数指针f赋值给函数指针变量p	
auto g = [m](int x)mutable->int{  ++m;return m; }; //准对象lambda表达式	
//p = g;             //错误：g是一个准对象，不能赋值给函数指针p