Chúng ta nên vượt qua shared_ptr theo tham chiếu hoặc theo giá trị?

Khi một hàm mất shared_ptr(từ boost hoặc C ++ 11 STL), bạn có vượt qua nó không:

• bởi const tham khảo: void foo(const shared_ptr<T>& p)

• hoặc theo giá trị : void foo(shared_ptr<T> p)?

Tôi thích phương pháp đầu tiên vì tôi nghi ngờ nó sẽ nhanh hơn. Nhưng điều này có thực sự đáng giá hay có bất kỳ vấn đề nào khác không?

Bạn có thể vui lòng đưa ra lý do cho sự lựa chọn của bạn hoặc nếu trường hợp, tại sao bạn nghĩ rằng nó không quan trọng.

Câu hỏi này đã được Scott, Andrei và Herb thảo luận và trả lời trong phiên Ask Us Anything tại C ++ và Beyond 2011 . Xem từ 4:34 về shared_ptrhiệu suất và tính chính xác .

Một thời gian ngắn, không có lý do nào để vượt qua giá trị, trừ khi mục tiêu là chia sẻ quyền sở hữu đối tượng (ví dụ: giữa các cấu trúc dữ liệu khác nhau hoặc giữa các luồng khác nhau).

Trừ khi bạn có thể di chuyển - tối ưu hóa nó như được giải thích bởi Scott Meyers trong video thảo luận được liên kết ở trên, nhưng điều đó có liên quan đến phiên bản thực tế của C ++ mà bạn có thể sử dụng.

Một bản cập nhật lớn cho cuộc thảo luận này đã xảy ra trong Bảng tương tác của hội nghị GoNative 2012 : Hỏi chúng tôi bất cứ điều gì! rất đáng xem, đặc biệt là từ 22h50 .

Đây là Herb Sutter của

Hướng dẫn: Không chuyển con trỏ thông minh làm tham số chức năng trừ khi bạn muốn sử dụng hoặc tự thao tác con trỏ thông minh, chẳng hạn như để chia sẻ hoặc chuyển quyền sở hữu.

Hướng dẫn: Thể hiện rằng một hàm sẽ lưu trữ và chia sẻ quyền sở hữu đối tượng heap bằng cách sử dụng tham số shared_ptr theo giá trị.

Hướng dẫn: Chỉ sử dụng một tham số không phải là const_ptr & để sửa đổi shared_ptr. Chỉ sử dụng const shared_ptr & làm tham số nếu bạn không chắc chắn liệu mình có lấy bản sao và chia sẻ quyền sở hữu hay không; mặt khác sử dụng widget * thay vào đó (hoặc nếu không thể null, một widget &).

Cá nhân tôi sẽ sử dụng một consttài liệu tham khảo. Không cần phải tăng số tham chiếu chỉ để giảm nó một lần nữa vì lợi ích của một cuộc gọi chức năng.

Đi qua consttham khảo, nó nhanh hơn. Nếu bạn cần lưu trữ nó, hãy nói trong một số container, ref. số lượng sẽ được tự động tăng lên một cách kỳ diệu bởi hoạt động sao chép.

Tôi chạy vào mã bên dưới, một lần với foolấy shared_ptrbằng const&và một lần nữa với foolấy shared_ptrtheo giá trị.

void foo(const std::shared_ptr<int>& p)
{
    static int x = 0;
    *p = ++x;
}

int main()
{
    auto p = std::make_shared<int>();
    auto start = clock();
    for (int i = 0; i < 10000000; ++i)
    {
        foo(p);
    }    
    std::cout << "Took " << clock() - start << " ms" << std::endl;
}

Sử dụng VS2015, bản phát hành x86, trên bộ xử lý intel core 2 quad (2.4GHz) của tôi

const shared_ptr&     - 10ms  
shared_ptr            - 281ms 

Bản sao theo phiên bản giá trị là một thứ tự cường độ chậm hơn.
Nếu bạn đang gọi một chức năng đồng bộ từ luồng hiện tại, hãy chọn const&phiên bản.

Vì C ++ 11, bạn nên lấy nó theo giá trị so với const & thường xuyên hơn bạn nghĩ.

Nếu bạn đang dùng std :: shared_ptr (chứ không phải loại T cơ bản), thì bạn đang làm như vậy vì bạn muốn làm gì đó với nó.

Nếu bạn muốn sao chép nó ở đâu đó, sẽ có ý nghĩa hơn khi lấy nó bằng cách sao chép và std :: di chuyển nó bên trong, thay vì lấy nó bằng const & và sau đó sao chép nó. Điều này là do bạn cho phép người gọi tùy chọn lần lượt std :: di chuyển shared_ptr khi gọi hàm của bạn, do đó tiết kiệm cho mình một tập hợp các hoạt động tăng và giảm. Hay không. Nghĩa là, người gọi hàm có thể quyết định liệu anh ta có cần std :: shared_ptr hay không sau khi gọi hàm, và tùy thuộc vào việc có di chuyển hay không. Điều này là không thể đạt được nếu bạn vượt qua const &, và do đó tốt nhất là lấy nó theo giá trị.

Tất nhiên, nếu cả hai người gọi đều cần shared_ptr của mình lâu hơn (do đó không thể std :: di chuyển nó) và bạn không muốn tạo một bản sao đơn giản trong hàm (giả sử bạn muốn một con trỏ yếu hoặc đôi khi bạn chỉ muốn để sao chép nó, tùy thuộc vào một số điều kiện), sau đó một const & có thể vẫn thích hợp hơn.

Ví dụ, bạn nên làm

void enqueue(std::shared<T> t) m_internal_queue.enqueue(std::move(t));

kết thúc

void enqueue(std::shared<T> const& t) m_internal_queue.enqueue(t);

Bởi vì trong trường hợp này bạn luôn tạo một bản sao trong nội bộ

Không biết chi phí thời gian của hoạt động sao chép shared_copy trong đó tăng và giảm nguyên tử, tôi gặp phải vấn đề sử dụng CPU cao hơn nhiều. Tôi không bao giờ mong đợi sự gia tăng và giảm nguyên tử có thể tốn nhiều chi phí như vậy.

Theo kết quả thử nghiệm của tôi, tăng và giảm nguyên tử int32 mất 2 hoặc 40 lần so với tăng và giảm không nguyên tử. Tôi đã nhận nó trên 3GHz Core i7 với Windows 8.1. Kết quả trước xuất hiện khi không có tranh chấp xảy ra, kết quả sau khi khả năng tranh chấp cao xảy ra. Tôi nhớ rằng các hoạt động nguyên tử là ở khóa dựa trên phần cứng cuối cùng. Khóa là khóa. Xấu đến hiệu suất khi xảy ra tranh chấp.

Trải qua điều này, tôi luôn sử dụng byref (const shared_ptr &) hơn byval (shared_ptr).

Có một bài đăng trên blog gần đây: https://medium.com/@vgasparyan1995/pass-by-value-vs-pass-by-reference-to-const-c-f8944171e3ce

Vì vậy, câu trả lời cho điều này là: Làm (gần như) không bao giờ đi qua const shared_ptr<T>&.
Đơn giản chỉ cần vượt qua lớp cơ bản thay thế.

Về cơ bản các loại tham số hợp lý duy nhất là:

• shared_ptr<T> - Sửa đổi và sở hữu
• shared_ptr<const T> - Đừng sửa đổi, hãy sở hữu
• T& - Sửa đổi, không có quyền sở hữu
• const T& - Không sửa đổi, không có quyền sở hữu
• T - Không sửa đổi, không có quyền sở hữu, Giá rẻ để sao chép

Như @accel đã chỉ ra trong https://stackoverflow.com/a/26197326/1930508 lời khuyên từ Herb Sutter là:

Chỉ sử dụng const shared_ptr & làm tham số nếu bạn không chắc chắn liệu mình có lấy bản sao và chia sẻ quyền sở hữu hay không

Nhưng trong bao nhiêu trường hợp bạn không chắc chắn? Vì vậy, đây là một tình huống hiếm gặp

Vấn đề đã biết là việc chia sẻ shared_ptr theo giá trị có chi phí và nên tránh nếu có thể.

Chi phí chuyển qua shared_ptr

Hầu hết thời gian vượt qua shared_ptr bằng tham chiếu, và thậm chí tốt hơn bởi tham chiếu const, sẽ làm.

Nguyên tắc cốt lõi cpp có một quy tắc cụ thể để truyền shared_ptr

R.34: Lấy tham số shared_ptr để thể hiện rằng hàm là chủ sở hữu một phần

void share(shared_ptr<widget>);            // share -- "will" retain refcount

Một ví dụ về việc khi chia sẻ shared_ptr theo giá trị là thực sự cần thiết là khi người gọi chuyển một đối tượng được chia sẻ sang một callee không đồng bộ - tức là người gọi đi ra khỏi phạm vi trước khi callee hoàn thành công việc của mình. Callee phải "kéo dài" thời gian tồn tại của đối tượng được chia sẻ bằng cách lấy share_ptr theo giá trị. Trong trường hợp này, chuyển tham chiếu đến shared_ptr sẽ không làm.

Cũng vậy với việc chuyển một đối tượng chia sẻ đến một luồng công việc.

shared_ptr không đủ lớn, cũng như hàm tạo \ hàm hủy của nó làm đủ công việc để có đủ chi phí từ bản sao để quan tâm đến việc chuyển bằng tham chiếu so với hiệu suất sao chép.