Lambda 表达式和函数指针

Lambda 表达式和函数指针

1. 什么是Lambda表达式？

C++11引入了Lambda表达式，它是一种用于创建匿名函数的方法。Lambda表达式在编写更简洁、清晰的代码时非常有用，特别是在需要传递函数作为参数的情况下，比如STL算法、自定义排序函数、回调等。

Lambda表达式的一般形式如下：

[捕获列表](参数列表) mutable-> 返回类型 {
    // 函数体
}

让我们详细讲解Lambda表达式的各个部分以及如何使用它们：

1. 捕获列表（Capture List）：Lambda表达式可以在其内部访问外部作用域的变量。捕获列表用于指定Lambda表达式需要捕获哪些外部变量以供使用。（不能省略）

   捕获列表有三种形式：

   • []：不捕获任何变量。
   • [变量名]：捕获指定变量（复制捕获）。

• [&变量名]：引用捕获，以引用方式访问变量（引用捕获）。
  • [=]：以复制捕获方式捕获所有外部变量。
  • [&]：以引用捕获方式捕获所有外部变量。

2. 参数列表（Parameter List）：与普通函数类似，如果不需要参数传递，则可以连同（）一起省略，用于指定Lambda表达式的参数列表。

3. 返回类型（Return Type）：可以省略，编译器可以自动推断返回类型。如果存在返回语句，编译器会根据返回语句推断返回类型。如果Lambda表达式中包含多条语句，且需要指定返回类型，可以使用->符号。

4. mutable : 默认情况下，lambda总是一个const函数，mutable可以取消其常量性，使用该修饰符时，参数列表不可省略（即使参数为空）。mutable放在参数列表和返回值之间。

5. 函数体（Function Body）：Lambda表达式的具体实现，包含要执行的代码(不能省略）。

总的来说，在lambda函数定义中，参数列表和返回值都是可选部分，而捕获列表和函数体可以为空。C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情，没有意义。

下面是一个简单的例子，展示了如何使用Lambda表达式来排序一个整数向量：

#include 
#include 
#include 

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 3};

    // 使用Lambda表达式进行升序排序
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a < b;
    });

    // 输出排序后的结果
    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

在这个例子中，Lambda表达式被传递给了std::sort算法作为排序准则。Lambda表达式捕获了外部变量，即在方括号内的捕获列表为空，表示不捕获任何外部变量。参数列表指定了两个整数参数，用于比较大小。Lambda的函数体中定义了比较规则，即a < b。

我们再来看一下一些例子：

#include

using namespace std;

int main()
{
	//最简单的lambda表达式
	auto func0 = [] {};

	//省略返回类型
	int num1 = 21, num2 = 34;
	auto func1 = [num1,num2](int a) {return num1 + num2+a; };
	cout << func1(23) << endl;

	auto func2 = [&num1, &num2]() {num2 = num1 * 2; };
	func2();
	cout << num2 << " " << endl;

	//捕捉类型可以是lambda表达式
	auto func3 = [func1](int a) {cout << func1(a) << endl; };

	//完整的lambda表达式
	auto func4 = [=](int a)->int {return num2 - num1+a; };

	//func3 = func2;   lambda之间无法赋值

	//lambda表达式可以拷贝
	auto func5(func4);
	cout << func5(10) << endl;


	//lambda直接赋值给函数指针
	//当然，此时捕获列表的参数应该为空
	void( *p0 )( ) = func0;
	auto func6 = [](int a)->int {return a * 2; };
	int( *p )( int ) = func6;
	cout << p(5) << endl;
	return 0;
}

Lambda表达式还可以用于其他许多情况，如STL算法、STL容器的成员函数、自定义的算法等等。它使得代码更加简洁，同时避免了需要显式编写命名函数的繁琐。

2. Lambda表达式的作用和使用场景

1. 作用：

   • 方便性：Lambda表达式允许在需要函数对象的地方以更紧凑的方式定义匿名函数。
   • 可读性：它可以提高代码的可读性，因为函数逻辑与其使用的上下文更密切相关。
   • 局部性：Lambda允许在其中定义函数的地方捕获外部变量，使得函数对象可以访问外部变量。

2. 使用场景：

   • Lambda常用于STL算法，如std::for_each，以提供自定义操作。
   • 在多线程编程中，Lambda可用于创建并行任务。
   • 在函数对象不太复杂的情况下，Lambda可以替代传统的函数对象类。

3. 示例：

   // Lambda表达式示例，计算平方和
   #include 
   #include 
   #include 
   
   int main() {
       std::vector<int> nums = {1, 2, 3, 4, 5};
       int sum = 0;
       // Lambda表达式捕获外部sum变量，并对nums中的元素求平方和
       std::for_each(nums.begin(), nums.end(), [&sum](int x) {
           sum += x * x;
       });
       std::cout << "平方和：" << sum << std::endl;
       return 0;
   }
   

   在此示例中，Lambda表达式捕获了外部的sum变量，并将其用于计算平方和。

3. 使用Lambda表达式需要注意的地方

当使用Lambda表达式时，有一些注意事项需要考虑：

1. 捕获外部变量：在Lambda表达式中，捕获外部变量可以使其在Lambda函数体内可见。但是需要注意以下几点：

   • 默认情况下，捕获的外部变量是只读的。如果需要在Lambda内部修改捕获的变量，可以使用引用捕获（[&]或[&变量名]）。
   • 引用捕获可能导致悬垂引用（dangling reference），即在Lambda执行后访问了已经超出作用域的变量。确保在Lambda引用的变量在Lambda执行期间保持有效。
   • 值捕获（[=]或[变量名]）会在Lambda创建时将外部变量的值拷贝到Lambda内部。这可能会导致性能开销，特别是在捕获大对象时。

2. 生命周期问题：Lambda表达式中捕获的局部变量（尤其是通过引用捕获）在Lambda表达式外部作用域结束时可能已经失效。确保Lambda表达式内部不会访问超出作用域的变量。

3. 指定返回类型：在Lambda表达式中，如果函数体中有多条语句，编译器可能无法自动推断返回类型。在这种情况下，需要使用->指定返回类型。

4. 自动类型推断：C++11引入了自动类型推断，使得在很多情况下不需要显式指定类型。Lambda表达式的参数列表和返回类型可以省略，编译器会根据上下文自动推断类型。

5. 可读性与复杂性：Lambda表达式可以使代码更紧凑，但过于复杂的Lambda表达式可能会降低代码的可读性。确保Lambda表达式的逻辑保持简洁和清晰，不至于让其他人难以理解。

6. Lambda与函数指针/函数对象：Lambda表达式的语法糖使其比传统的函数指针或函数对象更易于使用。然而，在一些特定情况下（如需要在多个地方重复使用相同的函数对象），传统方式可能更有优势。

7. Lambda作为参数：当将Lambda表达式作为函数参数传递时，需要注意Lambda的类型。使用auto关键字来声明接收Lambda的参数类型是一个常见做法。

总之，Lambda表达式是一个非常强大的特性，可以使C++代码更加灵活和简洁。但在使用时需要注意作用域、变量捕获方式、返回类型推断以及代码可读性等问题，以确保代码的正确性和可维护性。

Lambda表达式是C++11引入的重要功能，它使代码更具表现力和可维护性，特别是在现代C++编程中广泛使用。

4. lambda表达式和仿函数

函数对象又称为仿函数，即可以像函数一样使用的对象。就是在类中重载了operator()运算符的类对象。
从使用方式上来看，函数对象与lambda表达式完全一样。

下面是一个仿函数的例子：

#include
using namespace std;

//仿函数的定义
class SUM {
public:
	double operator()(double a, int b)const 
	{
		return a+b;
	}
};

int main()
{
	//仿函数的使用
	double a = 12.5;
    int b = 12;
	SUM add;
	cout<<add(12.5,12)<<endl;


	return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则。

这时候我们再对比一下仿函数和lambda表达式的之间的区别：

//这时候使用仿函数
#include
#include
#include
using namespace std;
struct People {
	string name;
	int age;
};
 
struct Compare
{
	bool operator()(const People& p1, const People& p2)
	{
		return p1.age <= p2.age;
	}
};
 
int main()
{
	People p[] = { {"小明",13},{"小红",15}};
	//仿函数
    sort(p, p + sizeof(p) / sizeof(p[0]), Compare());
    //lambda表达式
    sort(p,p+sizeof(p)/sizeof(p[0]),[](const People& p1,const        People& p2)->bool{
	return p1.age<=p2.age;	
    });
	for ( int i = 0; i < 2; i++ )
	{
		cout << p[i].name << " " << p[i].age << endl;
	}
}

显然，我们可以看到，使用lambda表达式的例子更简洁，且代码逻辑更直观。

5. 函数指针

函数指针是一个指向函数的指针变量，它可以用来调用特定的函数。在C++中，函数指针的使用可以帮助实现回调机制、动态选择调用的函数等。下面是函数指针的基本概念以及如何使用的详细讲解：

函数指针的声明：

函数指针的声明形式与函数的声明相似，只需要在函数名前加上指针运算符*。例如，一个接受两个整数参数并返回整数的函数指针的声明如下：

int (*functionPtr)(int, int);

这里的functionPtr就是一个指向函数的指针，它可以指向具有相同参数列表和返回类型的函数。

函数指针的赋值：

将函数指针指向特定函数时，可以直接将函数名赋值给函数指针。例如，假设有以下函数：

int Add(int a, int b) {
    return a + b;
}

可以将函数指针指向这个函数：

int (*functionPtr)(int, int) = Add;

通过函数指针调用函数：

通过函数指针调用函数与直接调用函数类似，使用函数指针名称加上参数列表进行调用。例如：

int result = functionPtr(3, 4);

这将调用Add(3, 4)函数并将结果赋值给result变量。

使用函数指针实现回调：

函数指针常常用于实现回调机制，其中一个函数可以作为参数传递给另一个函数，然后在后者内部通过函数指针调用传递的函数。这在事件处理、异步编程等方面非常有用。

以下是一个简单的例子，展示如何使用函数指针实现回调：

#include 

// 回调函数类型定义
typedef void (*Callback)(int);

// 使用回调函数的函数
void PerformOperation(int value, Callback callback) {
    // 执行某个操作
    std::cout << "Performing operation with value: " << value << std::endl;
    
    // 调用回调函数
    callback(value);
}

// 回调函数示例
void CallbackFunction(int value) {
    std::cout << "Callback executed with value: " << value << std::endl;
}

int main() {
    // 使用回调函数调用 PerformOperation
    PerformOperation(42, CallbackFunction);
    
    return 0;
}

在这个例子中，Callback被定义为接受一个整数参数并返回空（void）的函数指针类型。PerformOperation函数接受一个整数和一个回调函数作为参数，在函数内部先执行操作，然后通过回调函数指针调用回调函数。

最后，CallbackFunction作为回调函数被传递给了PerformOperation。运行程序后，你会看到回调函数被执行。

6. 函数指针的作用

可能有很多读者有这样一个疑惑，像上面那样写有什么意义，在PerformOperation中直接调用CallbackFunction函数不就好了？

这样的的疑问是合理的。在上面的例子中，似乎的确可以直接在PerformOperation函数内部调用CallbackFunction函数，而不需要使用回调函数和函数指针。然而，我使用这个简单的例子是为了更直观地展示函数指针的概念和用法，而实际中函数指针的用途通常更加复杂和实际。

我们先来看一下函数指针和回调函数有什么作用。

函数指针和回调函数的实际应用：

1. 动态选择函数：函数指针允许你在运行时根据需要选择要调用的函数。这在处理不同的情况、条件下需要不同的处理逻辑时非常有用。
2. 事件处理和回调机制：在事件驱动的程序中，函数指针用于指定事件发生时应该调用的函数，实现了回调机制。这使得代码更具可扩展性和灵活性。
3. 可插拔组件：函数指针允许你将特定功能的实现从核心代码中解耦，使得代码模块更加独立和可维护。
4. 库函数的扩展性：许多库函数允许你传递函数指针，以便在库函数的内部调用你提供的逻辑。这使得你能够自定义库函数的行为。
5. 依赖注入：在某些设计模式和编程实践中，函数指针可以用于实现依赖注入，即将函数作为参数传递给其他函数或对象。

虽然在简单的情况下，直接调用函数可能更简洁，但在复杂的应用场景中，使用函数指针可以使代码更加模块化、可扩展和灵活。最终，函数指针的价值在于它们提供了一种将代码解耦、分离关注点的方式，从而实现更好的可维护性和代码组织。

当涉及更复杂的应用场景时，函数指针的价值变得更为明显。我们再来看看下面的案例：

1. 排序算法的灵活性：

假设你有一个通用的排序函数，但你想根据需要选择是升序还是降序排序。使用函数指针，你可以动态选择排序规则。

#include 
#include 

// 排序函数类型定义
typedef bool (*CompareFunction)(int, int);

bool Ascending(int a, int b) {
    return a < b;
}

bool Descending(int a, int b) {
    return a > b;
}

void Sort(int* arr, int size, CompareFunction compareFn) {
    std::sort(arr, arr + size, compareFn);
}

int main() {
    int arr[] = {5, 2, 8, 1, 3};
    int size = sizeof(arr) / sizeof(arr[0]);

    // 升序排序
    Sort(arr, size, Ascending);
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 降序排序
    Sort(arr, size, Descending);
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

2. 事件处理和回调机制：

假设你正在编写一个图形界面库，你可以使用函数指针来实现事件处理和回调机制。

#include 
#include 

// 事件回调函数类型定义
typedef std::function<void()> EventCallback;

class Button {
public:
    void SetClickCallback(EventCallback callback) {
        clickCallback = callback;
    }

    void Click() {
        if (clickCallback) {
            clickCallback();
        }
    }
private:
    EventCallback clickCallback;
};

int main() {
    Button button;

    // 注册点击事件的回调函数
    button.SetClickCallback([]() {
        std::cout << "Button clicked!" << std::endl;
    });

    // 模拟按钮点击
    button.Click();

    return 0;
}

这个例子中，Button类具有一个点击事件的回调函数，你可以使用SetClickCallback方法来注册点击事件的处理逻辑。这种模式在GUI框架中非常常见。

3. 函数选择器：

假设你正在开发一个数学计算库，你可以使用函数指针来根据需要选择合适的数学函数。

#include 
#include 

typedef double (*MathFunction)(double);

double Square(double x) {
    return x * x;
}

double Cube(double x) {
    return x * x * x;
}

void ComputeAndPrint(MathFunction function, double value) {
    double result = function(value);
    std::cout << "Result: " << result << std::endl;
}

int main() {
    double number = 2.0;

    ComputeAndPrint(Square, number);
    ComputeAndPrint(Cube, number);

    return 0;
}

这个例子中，ComputeAndPrint函数可以根据所传入的函数指针选择合适的数学函数进行计算并输出结果。

这些示例展示了函数指针在更复杂的应用中的用途，包括算法的灵活性、事件处理、函数选择等。在实际开发中，这些概念可以帮助你编写更具模块化、灵活性和可扩展性的代码。

总之，函数指针是一个强大的工具，可以用于实现各种高级的编程技术，如回调、函数选择等。不过需要注意函数指针的声明、赋值和使用方法，以确保正确地使用它们。