Tại sao lambdas có thể được tối ưu hóa tốt hơn bởi trình biên dịch so với các hàm đơn giản?

Trong cuốn sách của mình, The C++ Standard Library (Second Edition)Nicolai Josuttis nói rằng lambdas có thể được trình biên dịch tối ưu hóa tốt hơn so với các hàm đơn giản.

Ngoài ra, trình biên dịch C ++ tối ưu hóa lambdas tốt hơn so với các chức năng thông thường. (Trang 213)

Tại sao vậy?

Tôi nghĩ rằng khi nói đến nội tuyến thì không nên có bất kỳ sự khác biệt nào nữa. Lý do duy nhất tôi có thể nghĩ đến là các trình biên dịch có thể có bối cảnh cục bộ tốt hơn với lambdas và như vậy có thể đưa ra nhiều giả định hơn và thực hiện nhiều tối ưu hóa hơn.

Lý do là lambdas là các đối tượng chức năng nên việc chuyển chúng vào một mẫu hàm sẽ khởi tạo một chức năng mới dành riêng cho đối tượng đó. Do đó, trình biên dịch có thể nội tuyến một cách tầm thường cuộc gọi lambda.

Mặt khác, đối với các hàm, cảnh báo cũ được áp dụng: một con trỏ hàm được chuyển đến mẫu hàm và các trình biên dịch theo truyền thống có rất nhiều vấn đề khi thực hiện các cuộc gọi thông qua các con trỏ hàm. Về mặt lý thuyết chúng có thể được nội tuyến, nhưng chỉ khi chức năng xung quanh cũng được nội tuyến.

Ví dụ, xem xét mẫu hàm sau:

template <typename Iter, typename F>
void map(Iter begin, Iter end, F f) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Gọi nó bằng lambda như thế này:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

Kết quả trong phần khởi tạo này (được tạo bởi trình biên dịch):

template <>
void map<int*, _some_lambda_type>(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end; ++begin)
        *begin = f.operator()(*begin);
}

Trình biên dịch biết _some_lambda_type::operator ()và có thể gọi nội tuyến một cách tầm thường. (Và việc gọi hàm mapvới bất kỳ lambda nào khác sẽ tạo ra một khởi tạo mới mapvì mỗi lambda có một loại riêng biệt.)

Nhưng khi được gọi bằng một con trỏ hàm, phần khởi tạo trông như sau:

template <>
void map<int*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Càng và ở đây fchỉ đến một địa chỉ khác nhau cho mỗi cuộc gọi mapvà do đó trình biên dịch không thể gọi nội tuyến ftrừ khi cuộc gọi xung quanh mapcũng đã được nội tuyến để trình biên dịch có thể phân giải fthành một chức năng cụ thể.

Bởi vì khi bạn chuyển một "hàm" cho một thuật toán, thực tế bạn đang chuyển một con trỏ tới hàm để nó phải thực hiện một cuộc gọi gián tiếp thông qua con trỏ đến hàm. Khi bạn sử dụng lambda, bạn đang chuyển một đối tượng đến một thể hiện mẫu được khởi tạo đặc biệt cho loại đó và cuộc gọi đến hàm lambda là một cuộc gọi trực tiếp, không phải là một cuộc gọi thông qua một con trỏ hàm nên rất có thể được nội tuyến.