Tôi có nên vượt qua hàm std :: bằng const-Reference không?

Giả sử tôi có một hàm có std::function:

void callFunction(std::function<void()> x)
{
    x();
}

Tôi có nên vượt qua xtham chiếu const thay thế?:

void callFunction(const std::function<void()>& x)
{
    x();
}

Có câu trả lời cho câu hỏi này thay đổi tùy thuộc vào chức năng làm gì với nó không? Ví dụ, nếu đó là một hàm thành viên lớp hoặc hàm tạo để lưu trữ hoặc khởi tạo std::functionbiến thành một biến thành viên.

Nếu bạn muốn hiệu suất, vượt qua giá trị nếu bạn đang lưu trữ nó.

Giả sử bạn có một hàm gọi là "chạy cái này trong luồng UI".

std::future<void> run_in_ui_thread( std::function<void()> )

chạy một số mã trong luồng "ui", sau đó báo hiệu futurekhi hoàn thành. (Hữu ích trong các khung UI, trong đó luồng UI là nơi bạn có nghĩa vụ phải làm rối với các thành phần UI)

Chúng tôi có hai chữ ký chúng tôi đang xem xét:

std::future<void> run_in_ui_thread( std::function<void()> ) // (A)
std::future<void> run_in_ui_thread( std::function<void()> const& ) // (B)

Bây giờ, chúng tôi có thể sử dụng những điều này như sau:

run_in_ui_thread( [=]{
  // code goes here
} ).wait();

cái này sẽ tạo ra một bao đóng ẩn danh (lambda), xây dựng std::functionnó, chuyển nó đến run_in_ui_threadhàm, sau đó đợi nó chạy xong trong luồng chính.

Trong trường hợp (A), std::functionđược xây dựng trực tiếp từ lambda của chúng tôi, sau đó được sử dụng trong run_in_ui_thread. Lambda là moved vào std::function, vì vậy bất kỳ trạng thái di chuyển nào được thực hiện một cách hiệu quả vào nó.

Trong trường hợp thứ hai, một tạm thời std::functionđược tạo ra, lambda được moveđưa vào đó, sau đó tạm thời std::functionđược sử dụng bởi tham chiếu trong run_in_ui_thread.

Cho đến nay, rất tốt - hai người họ thực hiện giống hệt nhau. Ngoại trừ việc run_in_ui_threadsẽ tạo một bản sao của đối số chức năng của nó để gửi đến luồng ui để thực thi! (nó sẽ trở lại trước khi nó được thực hiện với nó, vì vậy nó không thể chỉ sử dụng một tham chiếu đến nó). Đối với trường hợp (A), chúng tôi chỉ đơn giản là movecác std::functionthành lưu trữ lâu dài của nó. Trong trường hợp (B), chúng tôi buộc phải sao chép std::function.

Cửa hàng đó làm cho việc đi qua giá trị tối ưu hơn. Nếu có bất kỳ khả năng nào bạn đang lưu trữ một bản sao của std::function, vượt qua giá trị. Mặt khác, một trong hai cách là tương đương nhau: nhược điểm duy nhất của giá trị phụ là nếu bạn đang sử dụng cùng std::functionmột phương pháp cồng kềnh và có một phương thức phụ sau khi sử dụng phương pháp khác. Chặn rằng, a movesẽ hiệu quả như a const&.

Bây giờ, có một số khác biệt khác giữa hai chủ yếu là đá nếu chúng ta có trạng thái dai dẳng trong std::function.

Giả sử rằng std::functionlưu trữ một số đối tượng với a operator() const, nhưng nó cũng có một số mutablethành viên dữ liệu mà nó sửa đổi (thật thô lỗ!).

Trong std::function<> const&trường hợp, các mutablethành viên dữ liệu được sửa đổi sẽ truyền ra khỏi lệnh gọi hàm. Trong std::function<>trường hợp, họ sẽ không.

Đây là một trường hợp góc tương đối lạ.

Bạn muốn đối xử std::functionnhư bạn sẽ làm với bất kỳ loại di chuyển nặng, có thể nặng khác. Di chuyển là rẻ, sao chép có thể tốn kém.

Nếu bạn lo lắng về hiệu suất và bạn không xác định chức năng thành viên ảo, thì rất có thể bạn hoàn toàn không nên sử dụng std::function.

Việc tạo functor thành một tham số mẫu cho phép tối ưu hóa tốt hơn std::function, bao gồm cả nội tuyến logic functor. Hiệu quả của những tối ưu hóa này có khả năng vượt xa các mối quan tâm về sao chép và so sánh về cách vượt qua std::function.

Nhanh hơn:

template<typename Functor>
void callFunction(Functor&& x)
{
    x();
}

Như thường lệ trong C ++ 11, chuyển qua giá trị / tham chiếu / tham chiếu const phụ thuộc vào những gì bạn làm với đối số của mình. std::functionkhông khác

Truyền theo giá trị cho phép bạn di chuyển đối số thành một biến (thường là biến thành viên của một lớp):

struct Foo {
    Foo(Object o) : m_o(std::move(o)) {}

    Object m_o;
};

Khi bạn biết chức năng của mình sẽ di chuyển đối số của nó, đây là giải pháp tốt nhất, theo cách này người dùng của bạn có thể kiểm soát cách họ gọi chức năng của bạn:

Foo f1{Object()};               // move the temporary, followed by a move in the constructor
Foo f2{some_object};            // copy the object, followed by a move in the constructor
Foo f3{std::move(some_object)}; // move the object, followed by a move in the constructor

Tôi tin rằng bạn đã biết ngữ nghĩa của (không) tham chiếu const nên tôi sẽ không tin vào quan điểm. Nếu bạn cần tôi thêm giải thích thêm về điều này, chỉ cần hỏi và tôi sẽ cập nhật.