Tìm hiểu sâu về biểu thức lambda

Thuộc phần Lập trình hướng đối tượng trong hành trình C++ của Coddy. Bài học 85 trên 104.

Biểu thức lambda, được giới thiệu trong C++11, là các hàm ẩn danh mà bạn có thể định nghĩa ngay tại chỗ. Bạn đã thấy các lambda cơ bản với thuật toán STL, nhưng hiểu đầy đủ cú pháp của chúng sẽ giúp bạn khai thác các khả năng mạnh mẽ để nắm bắt biến và kiểm soát cách truy cập chúng.

Cú pháp lambda đầy đủ là: [capture](parameters) mutable -> return_type { body }. Mệnh đề capture xác định lambda có thể truy cập những biến bên ngoài nào và bằng cách nào:

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    auto byValue = [x]() { return x * 2; };        // Bản sao của x
    auto byRef = [&y]() { y += 5; };               // Tham chiếu đến y
    auto allByValue = [=]() { return x + y; };     // Sao chép tất cả
    auto allByRef = [&]() { x++; y++; };           // Tham chiếu đến tất cả
    auto mixed = [x, &y]() { y += x; };            // Kết hợp cả hai cách
    
    byRef();
    std::cout << y << "\n";  // 25
}

Theo mặc định, các biến được bắt theo giá trị là const bên trong lambda. Từ khóa mutable cho phép sửa đổi các bản sao này:

int counter = 0;
auto increment = [counter]() mutable {
    return ++counter;  // Thay đổi bản sao của lambda
};

std::cout << increment() << "\n";  // 1
std::cout << increment() << "\n";  // 2
std::cout << counter << "\n";      // 0, giá trị ban đầu không đổi

C++14 bổ sung init captures, cho phép bạn tạo biến mới hoặc chuyển đối tượng vào lambda:

auto ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() {
    return *p;
};  // Quyền sở hữu chuyển sang lambda

Lambda đặc biệt hữu ích trong lập trình hướng đối tượng (OOP) khi bạn cần truyền hành vi làm tham số, chẳng hạn như callback, bộ so sánh tùy chỉnh hoặc bộ xử lý sự kiện, mà không cần định nghĩa các đối tượng hàm riêng.

Thử thách

Dễ

Hãy xây dựng một hệ thống xử lý sự kiện để minh họa sức mạnh của biểu thức lambda với các chế độ bắt giữ khác nhau. Bạn sẽ tạo một bộ điều phối sự kiện đơn giản để lưu trữ và gọi các callback, qua đó cho thấy lambda có thể bắt giữ trạng thái bên ngoài theo nhiều cách.

Bạn sẽ tổ chức code trong ba tệp:

EventDispatcher.h: Định nghĩa lớp EventDispatcher quản lý các callback sự kiện.
Bộ điều phối của bạn cần lưu trữ callback bằng std::vector chứa các std::function<void()>. Hãy thêm các phương thức sau:
- addCallback(std::function<void()> callback): thêm một callback vào danh sách
- fireAll(): gọi lần lượt tất cả callback đã lưu
- clear(): xóa tất cả callback
Bạn cần include <functional> và <vector>.
EventDispatcher.cpp: Triển khai các phương thức cho bộ điều phối. Phương thức fireAll() chỉ cần duyệt qua tất cả callback và gọi từng callback.
main.cpp: Đọc hai đầu vào:
1. Một số cơ sở (số nguyên)
2. Một hệ số nhân (số nguyên)
Tạo một EventDispatcher và minh họa các cách bắt giữ lambda khác nhau bằng cách thêm ba callback:
1. Một lambda bắt giữ số cơ sở theo giá trị và in ra: Base value: [base]
2. Một lambda bắt giữ hệ số nhân theo tham chiếu, tăng giá trị lên 1, rồi in ra: Multiplier after increment: [multiplier]
3. Một lambda mutable bắt giữ một biến đếm (được khởi tạo bằng 0) theo giá trị, tăng biến này mỗi lần được gọi và in ra: Call count: [counter]
Sau khi thêm tất cả callback, gọi fireAll() hai lần để xem các chế độ bắt giữ khác nhau hoạt động ra sao qua nhiều lần gọi. Giữa hai lần gọi fireAll(), in ra --- làm dấu phân cách.

Cuối cùng, sau cả hai lượt, in ra giá trị cuối cùng của biến hệ số nhân trong main để cho thấy việc bắt giữ theo tham chiếu đã ảnh hưởng đến biến này như thế nào: Final multiplier: [multiplier]

Ví dụ, với đầu vào 10 và 5:

Base value: 10
Multiplier after increment: 6
Call count: 1
---
Base value: 10
Multiplier after increment: 7
Call count: 1
Final multiplier: 7

Với đầu vào 42 và 0:

Base value: 42
Multiplier after increment: 1
Call count: 1
---
Base value: 42
Multiplier after increment: 2
Call count: 1
Final multiplier: 2

Lưu ý các hành vi chính: cách bắt giữ theo giá trị giữ nguyên số cơ sở ban đầu, cách bắt giữ theo tham chiếu sửa đổi biến hệ số nhân thực tế trong main (tích lũy qua các lần gọi), còn biến đếm của lambda mutable luôn có giá trị 1 ở mỗi lượt. Đó là vì fireAll() duyệt các callback theo giá trị: mỗi lượt gọi một bản sao mới của std::function đã lưu, trong đó biến đếm được bắt giữ bắt đầu từ 0 và tăng lên 1, nên trạng thái riêng của callback đã lưu không bao giờ thay đổi.

Tự làm thử

#include <iostream>
#include "EventDispatcher.h"

using namespace std;

int main() {
    int base;
    int multiplier;
    cin >> base;
    cin >> multiplier;
    
    EventDispatcher dispatcher;
    
    // TODO: Thêm một lambda bắt giữ base theo giá trị
    // Lambda này cần in ra: "Base value: [base]"
    
    // TODO: Thêm một lambda bắt giữ multiplier theo tham chiếu
    // Lambda này cần tăng multiplier thêm 1, rồi in ra: "Multiplier after increment: [multiplier]"
    
    // TODO: Thêm một lambda mutable bắt giữ biến đếm (khởi tạo bằng 0) theo giá trị
    // Lambda này cần tăng biến đếm rồi in ra: "Call count: [counter]"
    
    // TODO: Gọi fireAll() để chạy tất cả callback
    
    // TODO: In ra "---" làm dấu phân cách
    
    // TODO: Gọi lại fireAll()
    
    // TODO: In ra giá trị cuối cùng của multiplier: "Final multiplier: [multiplier]"
    
    return 0;
}