Cách sử dụng Lambda Expressions trong C++

Lambda Expressions đã trở thành một phần quan trọng của ngôn ngữ, mang lại tính linh hoạt và tiện lợi cho việc viết mã. Lambda Expressions cho phép bạn tạo ra các hàm ngắn gọn và linh hoạt mà không cần phải định nghĩa hàm riêng biệt. Điều này làm giảm đáng kể sự phức tạp của mã và tạo ra mã rõ ràng hơn. Trên thực tế, Lambda Expressions là một trong những tính năng mạnh mẽ nhất của C++11 và đã được mở rộng trong các phiên bản tiếp theo của ngôn ngữ.

Trong bài viết này, mình sẽ tìm hiểu sâu hơn về Lambda Expressions trong C++, bao gồm cú pháp, cách sử dụng, và các ứng dụng thực tế. Mình sẽ tìm hiểu cách Lambda Expressions giúp tăng tính linh hoạt và hiệu suất của mã, cũng như ưu điểm và nhược điểm của chúng.

Bắt đầu từ những khái niệm cơ bản, sẽ tiến tới những ứng dụng phức tạp hơn của Lambda Expressions trong việc giải quyết các vấn đề thực tế. Hãy cùng đi vào chi tiết với Lambda Expressions và khám phá tất cả những gì chúng có thể cung cấp cho quá trình lập trình C++.

Lambda Expressions trong C++ là gì?

Lambda Expressions trong C++ là một tính năng mạnh mẽ cho phép tạo ra các hàm ngắn gọn và linh hoạt trực tiếp trong mã, mà không cần phải định nghĩa hàm riêng biệt. Lambda Expressions cung cấp cách thức đơn giản và tự nhiên để viết các hàm ngắn một cách trực tiếp trong các đoạn mã, đặc biệt hữu ích khi bạn muốn truyền một hàm nhỏ hoặc phức tạp như một đối số cho một hàm khác hoặc khi bạn muốn viết mã linh hoạt và ngắn gọn hơn.

Bài viết này được đăng tại [free tuts .net]

Ý nghĩa và vai trò của Lambda Expressions:

• Tăng tính linh hoạt: Lambda Expressions cho phép bạn tạo ra các hàm ngắn gọn trực tiếp trong vị trí cần thiết, giúp tăng tính linh hoạt của mã và giảm sự phức tạp.

• Giảm độ phức tạp của mã: Bằng cách viết mã logic ngắn gọn và trực tiếp, Lambda Expressions giúp giảm độ phức tạp của mã và làm cho nó dễ đọc hơn.

• Tiết kiệm thời gian và công sức: Thay vì phải định nghĩa một hàm riêng biệt, Lambda Expressions cho phép bạn viết mã logic trực tiếp tại điểm sử dụng, tiết kiệm thời gian và công sức.

• Hỗ trợ trong việc viết mã chuyên sâu: Lambda Expressions là một công cụ hữu ích trong việc viết mã chuyên sâu, đặc biệt là trong việc xử lý sự kiện, lọc dữ liệu, hoặc thực hiện các thao tác tùy chỉnh trên các tập dữ liệu.

Tóm lại, Lambda Expressions là một công cụ mạnh mẽ trong ngôn ngữ lập trình C++ giúp tăng tính linh hoạt và hiệu suất của mã, đồng thời giảm bớt sự phức tạp và làm cho mã trở nên dễ hiểu hơn.

Cú pháp của Lambda Expressions trong C++

Lambda Expression có cú pháp như sau

[capture clause](parameter list) -> return type { body }

• Capture clause: Dùng để bắt giữ các biến từ phạm vi bên ngoài.
• Parameter list: Danh sách các tham số của hàm lambda.
• Return type: Kiểu dữ liệu của giá trị trả về của hàm lambda (có thể không cần).
• Body: Thân hàm, chứa các câu lệnh cần thực thi.

Các thành phần của một Lambda Expression

• Capture clause: Được sử dụng để bắt giữ các biến từ phạm vi bên ngoài và sử dụng chúng trong hàm lambda.
• Parameter list: Danh sách các tham số mà hàm lambda có thể nhận.
• Return type: Kiểu dữ liệu của giá trị trả về của hàm lambda. Nó có thể được tự động suy luận từ phần thân của lambda, nhưng có thể cần được chỉ định rõ ràng trong một số trường hợp.

Cách truyền tham số vào Lambda Expressions

Tham số có thể được truyền vào Lambda Expression thông qua danh sách tham số của nó. Dưới đây là một ví dụ minh họa:

#include <iostream>

int main() {
    // Lambda Expression nhận một tham số và trả về bình phương của nó
    auto square = [](int x) -> int {
        return x * x;
    };
    //Bài viết được đăng tại freetuts.net

    int num = 5;
    std::cout << "Square of " << num << " is: " << square(num) << std::endl;

    return 0;
}

Output:

Square of 5 is: 25

Trong ví dụ trên, mình đã tạo một hàm lambda square nhận một tham số x, và trả về bình phương của x. Tham số num được truyền vào lambda square và kết quả được in ra màn hình.

Capturing trong Lambda Expressions trong C++

Capturing by value

Trong trường hợp này, giá trị của biến được sao chép vào lambda và bất kỳ thay đổi nào đối với biến trong lambda cũng không ảnh hưởng đến biến gốc bên ngoài.

#include <iostream>

int main() {
    int num = 10;

    // Capture by value
    auto lambda = [num]() {
        std::cout << "Inside lambda: " << num << std::endl;
    };
     //Bài viết được đăng tại freetuts.net

    num = 20; // Change the value of num

    lambda(); // Still prints 10, because num is captured by value

    return 0;
}

Output:

Inside lambda: 10

Capturing by reference

Trong trường hợp này, tham chiếu đến biến được chia sẻ giữa lambda và phạm vi bên ngoài, do đó, bất kỳ thay đổi nào đối với biến trong lambda cũng ảnh hưởng đến biến gốc.

#include <iostream>

int main() {
    int num = 10;

    // Capture by reference
    auto lambda = [&num]() {
        std::cout << "Inside lambda: " << num << std::endl;
    };
     //Bài viết được đăng tại freetuts.net

    num = 20; // Change the value of num

    lambda(); // Prints 20, because num is captured by reference

    return 0;
}

Output:

Inside lambda: 20

Capturing cả giá trị và tham chiếu

Trong trường hợp này, mình có thể kết hợp cả hai cách capturing by value và by reference trong một lambda expression.

#include <iostream>

int main() {
    int num1 = 10;
    int num2 = 20;
     //Bài viết được đăng tại freetuts.net

    // Capture num1 by value and num2 by reference
    auto lambda = [num1, &num2]() {
        std::cout << "Inside lambda: " << num1 << ", " << num2 << std::endl;
        num2 = 30; // Change the value of num2
    };

    num1 = 50; // Change the value of num1

    lambda(); // Prints 10 (num1) and 20 (initial value of num2)
    std::cout << "After lambda: " << num1 << ", " << num2 << std::endl; // Prints 50 (num1) and 30 (modified value of num2)

    return 0;
}

Output:

Inside lambda: 10, 20
After lambda: 50, 30

Trong ví dụ này, num1 được chụp theo giá trị và num2 được chụp theo tham chiếu. Khi gọi lambda, nó in ra giá trị ban đầu của num1 và num2, sau đó thay đổi giá trị của num2 trong lambda và in ra giá trị mới của cả num1 và num2 sau khi lambda được gọi.

Ví dụ Lambda Expressions trong C++

Sử dụng Lambda Expressions trong việc sắp xếp một vector

#include <iostream>
#include <vector>
#include <algorithm>

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

    // Sắp xếp vector theo thứ tự tăng dần sử dụng lambda expression
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a < b;
    });
    //Bài viết được đăng tại freetuts.net

    // In ra vector đã sắp xếp
    std::cout << "Vector sau khi sắp xếp: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Vector sau khi sắp xếp: 1 1 2 3 3 4 5 5 6 9 

Sử dụng Lambda Expressions để lọc các phần tử của một vector

#include <iostream>
#include <vector>
#include <algorithm>

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

    // Lọc các số chẵn từ vector sử dụng lambda expression
    auto isEven = [](int num) {
        return num % 2 == 0;
    };
     //Bài viết được đăng tại freetuts.net

    numbers.erase(std::remove_if(numbers.begin(), numbers.end(), isEven), numbers.end());

    // In ra vector sau khi lọc
    std::cout << "Cac so le trong vector: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Cac so le trong vector: 3 1 1 5 9 5 3 

Sử dụng Lambda Expressions trong các thuật toán của STL

#include <iostream>
#include <vector>
#include <algorithm>

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

    // Tìm số lớn nhất trong vector sử dụng lambda expression
    auto maxNum = std::max_element(numbers.begin(), numbers.end(), [](int a, int b) {
        return a < b;
    });
    //Bài viết được đăng tại freetuts.net

    std::cout << "So lon nhat trong vector: " << *maxNum << std::endl;

    return 0;
}

Output:

So lon nhat trong vector: 9

Trong các ví dụ trên, mình sử dụng Lambda Expressions để tạo ra các hàm ẩn danh và truyền chúng vào các hàm thuật toán của STL như std::sort, std::remove_if, và std::max_element để thực hiện các thao tác như sắp xếp, lọc và tìm kiếm trong vector.

So sánh với các phương pháp khác trong C++

So sánh với function objects

Function objects là các đối tượng được tạo ra từ các lớp có hàm operator() được định nghĩa bên trong. Chúng có thể được sử dụng để thực hiện các thao tác tương tự như Lambda Expressions. Tuy nhiên, việc sử dụng Lambda Expressions thường đơn giản và linh hoạt hơn so với việc tạo và sử dụng function objects.

Ví dụ về sử dụng function objects để sắp xếp một vector

#include <iostream>
#include <vector>
#include <algorithm>
//Bài viết được đăng tại freetuts.net

// Function object để sắp xếp theo thứ tự giảm dần
struct Compare {
    bool operator()(int a, int b) {
        return a > b;
    }
};

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

    // Sắp xếp vector sử dụng function object
    std::sort(numbers.begin(), numbers.end(), Compare());

    // In ra vector đã sắp xếp
    std::cout << "Vector sau khi sắp xếp: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Vector sau khi sắp xếp: 9 6 5 5 4 3 3 2 1 1 

So sánh với function pointers

Function pointers là các con trỏ trỏ đến các hàm. Chúng cũng có thể được sử dụng để truyền vào các hàm thuật toán của STL. Tuy nhiên, việc sử dụng Lambda Expressions thường dễ đọc và dễ hiểu hơn so với việc sử dụng function pointers, đặc biệt khi cần truyền các biến cục bộ vào hàm.

Ví dụ về sử dụng function pointers để lọc các phần tử trong vector:

#include <iostream>
#include <vector>
#include <algorithm>

// Hàm so sánh để lọc các số chẵn
bool isEven(int num) {
    return num % 2 == 0;
}
//Bài viết được đăng tại freetuts.net

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

    // Lọc các số chẵn từ vector sử dụng function pointer
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(), isEven), numbers.end());

    // In ra vector sau khi lọc
    std::cout << "Cac so le trong vector: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Cac so le trong vector: 3 1 1 5 9 5 3 

Tóm lại, Lambda Expressions cung cấp một cú pháp ngắn gọn và tiện lợi hơn so với function objects và function pointers trong nhiều trường hợp. Đồng thời, chúng cũng cho phép truyền các biến cục bộ vào hàm một cách dễ dàng hơn.

Lưu ý khi sử dụng Lambda Expressions trong C++

Tránh việc sử dụng Lambda Expressions quá phức tạp

Lambda Expressions có thể trở nên phức tạp nếu được sử dụng quá mức. Khi viết Lambda, hãy cố gắng giữ cho mã nguồn dễ đọc và dễ hiểu bằng cách tách thành các biểu thức nhỏ hơn và sử dụng chú thích khi cần thiết. Nếu Lambda quá phức tạp, nó có thể trở thành nguy cơ cho sự bảo trì mã nguồn trong tương lai.

Hiểu rõ về quy tắc Capturing để tránh các lỗi không mong muốn

Khi sử dụng Lambda, quy tắc Capturing quy định cách biến nằm trong phạm vi của Lambda được truy cập. Sử dụng sai quy tắc Capturing có thể dẫn đến lỗi hoặc hành vi không mong muốn. Đảm bảo hiểu rõ về các loại Capturing như Capturing by value, Capturing by reference, và Capturing cả giá trị và tham chiếu để tránh các vấn đề tiềm ẩn.

Ví dụ:

#include <iostream>

void testLambda() {
    int x = 10;
    int y = 20;

    auto lambda = [=]() mutable {  // Capturing by value, mutable để thay đổi giá trị x trong Lambda
        std::cout << "x: " << x << ", y: " << y << std::endl;
        x++;
        // y++; // Lỗi, không thể thay đổi biến được captured by value
    };
     //Bài viết được đăng tại freetuts.net

    lambda();
    std::cout << "x after lambda: " << x << std::endl; // Kết quả: x sau khi được tăng là 11
}

int main() {
    testLambda();
    return 0;
}

Output:

x: 10, y: 20
x after lambda: 10

Trong ví dụ này, Lambda được capture giá trị của biến x (Capturing by value) và giữ nguyên biến y (Capturing by reference). Tuy nhiên, vì x được captured by value, nên để thay đổi giá trị của x trong Lambda, cần phải sử dụng từ khóa mutable.

Kết bài

Trong bài viết này, mình đã thảo luận về cách sử dụng Lambda Expressions trong ngôn ngữ lập trình C++. Lambda Expressions cung cấp một cách linh hoạt và tiện lợi để định nghĩa các hàm ngắn gọn và trực tiếp trong các ngữ cảnh như việc sắp xếp, lọc và xử lý dữ liệu.

Chúng ta đã tìm hiểu về cú pháp của Lambda, cách Capturing hoạt động và cách sử dụng Lambda trong các tình huống thực tế như sắp xếp và lọc dữ liệu. Chúng ta cũng đã thảo luận về các lưu ý quan trọng khi sử dụng Lambda, như tránh làm cho Lambda quá phức tạp và hiểu rõ về quy tắc Capturing để tránh các lỗi không mong muốn.

Bằng cách sử dụng Lambda Expressions, chúng ta có thể viết mã ngắn gọn và dễ đọc hơn, đồng thời cải thiện hiệu suất và linh hoạt trong lập trình C++.