Hàm tử 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 74 trên 104.

Nhiều thuật toán STL nhận một đối tượng có thể gọi để tùy chỉnh cách hoạt động. Bạn đã thấy lambda được dùng với std::transform. Hãy cùng tìm hiểu functor và biểu thức lambda (lambda expression), hai cách tạo đối tượng có thể gọi trong C++.

Functor (đối tượng hàm) là một lớp nạp chồng operator(), cho phép gọi các đối tượng như gọi hàm:

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

struct MultiplyBy {
    int factor;
    MultiplyBy(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
};

int main() {
    std::vector<int> nums = {1, 2, 3, 4};
    std::vector<int> result(nums.size());
    
    std::transform(nums.begin(), nums.end(), result.begin(), MultiplyBy(3));
    // result: {3, 6, 9, 12}
}

Mỗi đối tượng functor có thể giữ trạng thái độc lập riêng thông qua các biến thành viên được thiết lập khi khởi tạo, điều mà một lần gọi hàm thông thường không thể làm được. Tuy nhiên, việc định nghĩa một lớp cho các phép toán đơn giản khá dài dòng. Biểu thức lambda là một lựa chọn ngắn gọn hơn:

int factor = 3;
std::transform(nums.begin(), nums.end(), result.begin(),
               [factor](int x) { return x * factor; });

Cú pháp lambda là [capture](parameters) { body }. Mệnh đề capture chỉ định những biến bên ngoài mà lambda có thể truy cập. Dùng [=] để lấy tất cả biến theo giá trị, [&] để lấy tất cả biến theo tham chiếu, hoặc liệt kê các biến cụ thể như [factor] hoặc [&factor].

Hàm lambda đặc biệt hữu ích cho các thao tác chỉ dùng một lần với những thuật toán như sắp xếp theo tiêu chí tùy chỉnh:

std::vector<int> nums = {5, -2, 8, -1};
std::sort(nums.begin(), nums.end(), 
          [](int a, int b) { return std::abs(a) < std::abs(b); });
// Sắp xếp theo giá trị tuyệt đối: {-1, -2, 5, 8}

Thử thách

Dễ

Hãy xây dựng một chương trình tính giá để minh họa cả functor lẫn biểu thức lambda khi áp dụng các chiến lược giảm giá khác nhau cho giá sản phẩm.

Bạn sẽ sắp xếp code trong hai tệp:

Discounts.h: Định nghĩa các functor giảm giá và hàm tiện ích tại đây.
Tạo một functor có tên PercentageDiscount để lưu phần trăm giảm giá dưới dạng số nguyên. operator() của functor này nhận giá double và trả về giá sau khi giảm. Ví dụ, giảm giá 20% cho sản phẩm giá $100 sẽ trả về $80.

Tạo một functor khác có tên FixedDiscount để lưu một khoản tiền cố định cần trừ dưới dạng double. operator() của functor này nhận một mức giá và trả về giá đó trừ đi khoản tiền cố định, nhưng không bao giờ thấp hơn 0.

Tạo một hàm có tên printPrices nhận const std::vector<double>& và in tất cả mức giá, cách nhau bằng dấu cách, sau đó xuống dòng. Định dạng mỗi mức giá với hai chữ số thập phân.
main.cpp: Đọc năm đầu vào, mỗi đầu vào nằm trên một dòng riêng:
1. Giá sản phẩm thứ nhất (double)
2. Giá sản phẩm thứ hai (double)
3. Giá sản phẩm thứ ba (double)
4. Phần trăm giảm giá cần áp dụng (số nguyên, ví dụ: 20 cho mức giảm 20%)
5. Khoản tiền giảm giá cố định (double)
Tạo một vector chứa ba mức giá và minh họa cả hai cách:
1. In Original prices: theo sau là các mức giá
2. Dùng std::transform với functor PercentageDiscount để tạo một vector mới chứa các mức giá sau khi giảm. In After percentage discount: theo sau là kết quả
3. Dùng std::transform với functor FixedDiscount trên các mức giá ban đầu để tạo một vector khác. In After fixed discount: theo sau là kết quả
4. Dùng std::transform với biểu thức lambda để nhân đôi từng mức giá ban đầu. In Premium prices (doubled): theo sau là kết quả
5. Dùng std::sort với một lambda để sắp xếp các mức giá ban đầu theo thứ tự giảm dần. In Sorted (high to low): theo sau là các mức giá đã sắp xếp

Ví dụ, với các đầu vào 100.00, 50.00, 75.00, 20 và 15.00:

Original prices: 100.00 50.00 75.00 
After percentage discount: 80.00 40.00 60.00 
After fixed discount: 85.00 35.00 60.00 
Premium prices (doubled): 200.00 100.00 150.00 
Sorted (high to low): 100.00 75.00 50.00

Thử thách này giúp bạn so sánh functor, vốn duy trì trạng thái như khoản tiền giảm giá, với lambda, vốn nắm bắt biến để thực hiện nhanh các thao tác trực tiếp. Cả hai cách đều hoạt động liền mạch với các thuật toán STL như std::transform và std::sort.

Tự làm thử

#include <iostream>
#include <vector>
#include <algorithm>
#include "Discounts.h"

int main() {
    // Đọc dữ liệu đầu vào
    double price1, price2, price3;
    int percentageDiscount;
    double fixedDiscount;
    
    std::cin >> price1;
    std::cin >> price2;
    std::cin >> price3;
    std::cin >> percentageDiscount;
    std::cin >> fixedDiscount;
    
    // Tạo một vector chứa ba mức giá
    std::vector<double> prices = {price1, price2, price3};
    
    // TODO: In "Original prices:", sau đó in các mức giá bằng printPrices
    
    // TODO: Dùng std::transform với functor PercentageDiscount
    // Tạo một vector mới để lưu kết quả
    // In "After percentage discount:", sau đó in kết quả
    
    // TODO: Dùng std::transform với functor FixedDiscount cho các mức giá ban đầu
    // Tạo một vector mới để lưu kết quả
    // In "After fixed discount:", sau đó in kết quả
    
    // TODO: Dùng std::transform với một hàm lambda nhân đôi từng mức giá ban đầu
    // Tạo một vector mới để lưu kết quả
    // In "Premium prices (doubled):", sau đó in kết quả
    
    // TODO: Dùng std::sort với một hàm lambda để sắp xếp các mức giá ban đầu theo thứ tự giảm dần
    // In "Sorted (high to low):", sau đó in các mức giá đã sắp xếp
    
    return 0;
}