Tóm lại, sử dụngstd::function trừ khi bạn có lý do để không.
Con trỏ chức năng có nhược điểm là không thể chụp một số bối cảnh. Ví dụ, bạn sẽ không thể chuyển một hàm lambda dưới dạng gọi lại để nắm bắt một số biến bối cảnh (nhưng nó sẽ hoạt động nếu nó không nắm bắt được bất kỳ). Do đó, việc gọi một biến thành viên của một đối tượng (tức là không tĩnh) là không thể, vì đối tượng ( this-pulum) cần phải được bắt. (1)
std::function(vì C ++ 11) chủ yếu để lưu trữ một chức năng (truyền nó xung quanh không yêu cầu nó được lưu trữ). Do đó, nếu bạn muốn lưu trữ cuộc gọi lại chẳng hạn trong một biến thành viên, đó có lẽ là lựa chọn tốt nhất của bạn. Nhưng ngoài ra, nếu bạn không lưu trữ nó, đó là một "lựa chọn đầu tiên" tốt mặc dù nó có nhược điểm là giới thiệu một số chi phí (rất nhỏ) khi được gọi (vì vậy trong tình huống rất quan trọng về hiệu năng, nó có thể là một vấn đề nhưng trong hầu hết nó không nên). Nó rất "phổ quát": nếu bạn quan tâm nhiều đến mã nhất quán và dễ đọc cũng như không muốn nghĩ về mọi lựa chọn bạn đưa ra (tức là muốn giữ cho nó đơn giản), hãy sử dụng std::functioncho mọi chức năng bạn chuyển qua.
Hãy suy nghĩ về một tùy chọn thứ ba: Nếu bạn sắp thực hiện một chức năng nhỏ, sau đó báo cáo điều gì đó thông qua chức năng gọi lại được cung cấp, hãy xem xét một tham số mẫu , sau đó có thể là bất kỳ đối tượng có thể gọi nào , ví dụ như con trỏ hàm, hàm functor, lambda, a std::function, ... Hạn chế ở đây là chức năng (bên ngoài) của bạn trở thành một khuôn mẫu và do đó cần phải được thực hiện trong tiêu đề. Mặt khác, bạn có lợi thế là cuộc gọi đến cuộc gọi lại có thể được nội tuyến, vì mã máy khách của hàm (bên ngoài) của bạn "nhìn thấy" cuộc gọi đến cuộc gọi lại sẽ có thông tin loại chính xác.
Ví dụ cho phiên bản có tham số mẫu (viết &thay vì &&cho tiền C ++ 11):
template <typename CallbackFunction>
void myFunction(..., CallbackFunction && callback) {
...
callback(...);
...
}
Như bạn có thể thấy trong bảng sau, tất cả chúng đều có những ưu điểm và nhược điểm:
+-------------------+--------------+---------------+----------------+
| | function ptr | std::function | template param |
+===================+==============+===============+================+
| can capture | no(1) | yes | yes |
| context variables | | | |
+-------------------+--------------+---------------+----------------+
| no call overhead | yes | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be inlined | no | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be stored | yes | yes | no(2) |
| in class member | | | |
+-------------------+--------------+---------------+----------------+
| can be implemented| yes | yes | no |
| outside of header | | | |
+-------------------+--------------+---------------+----------------+
| supported without | yes | no(3) | yes |
| C++11 standard | | | |
+-------------------+--------------+---------------+----------------+
| nicely readable | no | yes | (yes) |
| (my opinion) | (ugly type) | | |
+-------------------+--------------+---------------+----------------+
(1) Giải pháp tồn tại để khắc phục giới hạn này, ví dụ: truyền dữ liệu bổ sung dưới dạng tham số tiếp theo cho hàm (bên ngoài) của bạn: myFunction(..., callback, data)sẽ gọi callback(data). Đó là "gọi lại với các đối số" theo kiểu C, có thể có trong C ++ (và bằng cách được sử dụng nhiều trong API WIN32) nhưng nên tránh vì chúng ta có các tùy chọn tốt hơn trong C ++.
(2) Trừ khi chúng ta đang nói về một mẫu lớp, tức là lớp mà bạn lưu trữ chức năng là một mẫu. Nhưng điều đó có nghĩa là về phía máy khách, loại hàm quyết định loại đối tượng lưu trữ cuộc gọi lại, gần như không bao giờ là một tùy chọn cho các trường hợp sử dụng thực tế.
(3) Đối với tiền C ++ 11, hãy sử dụng boost::function