Vấn đề
C ++ bao gồm các hàm chung hữu ích như std::for_eachvà std::transform, có thể rất tiện dụng. Thật không may, chúng cũng có thể khá cồng kềnh khi sử dụng, đặc biệt nếu functor mà bạn muốn áp dụng là duy nhất cho chức năng cụ thể.
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
Nếu bạn chỉ sử dụng fmột lần và ở nơi cụ thể đó, có vẻ như quá mức cần thiết để viết cả một lớp chỉ để làm một cái gì đó tầm thường và một cái.
Trong C ++ 03, bạn có thể muốn viết một cái gì đó như sau, để giữ functor cục bộ:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
tuy nhiên điều này không được phép, fkhông thể truyền cho hàm mẫu trong C ++ 03.
Giải pháp mới
C ++ 11 giới thiệu lambdas cho phép bạn viết một functor nội tuyến, ẩn danh để thay thế struct f. Đối với các ví dụ đơn giản nhỏ, điều này có thể dễ đọc hơn (nó giữ mọi thứ ở một nơi) và có khả năng duy trì đơn giản hơn, ví dụ ở dạng đơn giản nhất:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Các hàm Lambda chỉ là đường cú pháp cho hàm functor ẩn danh.
Trả về các loại
Trong các trường hợp đơn giản, kiểu trả về của lambda được suy ra cho bạn, ví dụ:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
tuy nhiên khi bạn bắt đầu viết lambdas phức tạp hơn, bạn sẽ nhanh chóng gặp phải trường hợp loại trả về không thể được suy ra bởi trình biên dịch, ví dụ:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
Để giải quyết vấn đề này, bạn được phép chỉ định rõ ràng loại trả về cho hàm lambda, sử dụng -> T:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
Các biến "Chụp"
Cho đến nay chúng ta không sử dụng bất cứ thứ gì ngoài những gì được truyền cho lambda trong đó, nhưng chúng ta cũng có thể sử dụng các biến khác, trong lambda. Nếu bạn muốn truy cập các biến khác, bạn có thể sử dụng mệnh đề chụp ( []biểu thức), cho đến nay vẫn chưa được sử dụng trong các ví dụ này, ví dụ:
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
Bạn có thể chụp theo cả tham chiếu và giá trị, mà bạn có thể chỉ định bằng cách sử dụng &và =tương ứng:
[&epsilon] chụp bằng cách tham khảo[&] nắm bắt tất cả các biến được sử dụng trong lambda bằng cách tham chiếu[=] nắm bắt tất cả các biến được sử dụng trong lambda theo giá trị[&, epsilon] nắm bắt các biến như với [&], nhưng epsilon theo giá trị[=, &epsilon] nắm bắt các biến như với [=], nhưng epsilon bằng cách tham chiếu
Được tạo ra operator()là consttheo mặc định, với ngụ ý rằng ảnh chụp sẽ được constkhi bạn truy cập chúng bằng cách mặc định. Điều này có tác dụng là mỗi cuộc gọi có cùng một đầu vào sẽ tạo ra cùng một kết quả, tuy nhiên bạn có thể đánh dấu lambda làmutable để yêu cầu cuộc gọi operator()được tạo ra không const.
