Tôi nên std :: di chuyển một shared_ptr trong một nhà xây dựng di chuyển?

Question

xem xét:

#include <cstdlib> 
#include <memory> 
#include <string> 
#include <vector> 
#include <algorithm> 
#include <iterator> 
using namespace std; 

class Gizmo 
{ 
public: 
    Gizmo() : foo_(shared_ptr<string>(new string("bar"))) {}; 
    Gizmo(Gizmo&& rhs); // Implemented Below 

private: 
    shared_ptr<string> foo_; 
}; 

/* 
// doesn't use std::move 
Gizmo::Gizmo(Gizmo&& rhs) 
: foo_(rhs.foo_) 
{ 
} 
*/ 


// Does use std::move 
Gizmo::Gizmo(Gizmo&& rhs) 
: foo_(std::move(rhs.foo_)) 
{ 
} 

int main() 
{ 
    typedef vector<Gizmo> Gizmos; 
    Gizmos gizmos; 
    generate_n(back_inserter(gizmos), 10000, []() -> Gizmo 
    { 
     Gizmo ret; 
     return ret; 
    }); 

    random_shuffle(gizmos.begin(), gizmos.end()); 

} 

Trong đoạn mã trên, có hai phiên bản của Gizmo::Gizmo(Gizmo&&) - một sử dụng std::move để thực sự di chuyển các shared_ptr, và người kia chỉ sao chép shared_ptr.

Cả hai phiên bản dường như hoạt động trên bề mặt. Một khác biệt (khác biệt duy nhất tôi có thể thấy) là trong phiên bản không move số tham chiếu của shared_ptr tạm thời tăng lên, nhưng chỉ một thời gian ngắn.

Tôi thường tiếp tục và moveshared_ptr, nhưng chỉ để rõ ràng và nhất quán trong mã của tôi. Tôi có thiếu cân nhắc ở đây không? Tôi có nên sử dụng phiên bản này so với phiên bản khác vì bất kỳ lý do kỹ thuật nào kỹ thuật không?

Answer 1

Vấn đề chính ở đây không phải là sự khác biệt hiệu suất nhỏ do tăng thêm nguyên tử và giảm trong shared_ptr nhưng ngữ nghĩa của thao tác không nhất quán trừ khi bạn thực hiện di chuyển.

Mặc dù giả định là số tham chiếu của shared_ptr sẽ chỉ là tạm thời nhưng không có sự bảo đảm như vậy trong ngôn ngữ. Đối tượng nguồn mà bạn đang di chuyển có thể là tạm thời, nhưng nó cũng có thể có tuổi thọ dài hơn nhiều. Nó có thể là một biến có tên đã được đúc để một rvalue tham chiếu (nói std::move(var)), trong trường hợp này bằng cách không di chuyển từ shared_ptr bạn vẫn được duy trì chia sẻ quyền sở hữu với nguồn gốc của sự di chuyển, và nếu đích shared_ptr có phạm vi nhỏ hơn thì tuổi thọ của đối tượng nhọn sẽ không cần thiết được mở rộng.

Answer 2

Việc sử dụng move là thích hợp hơn: nó phải hiệu quả hơn bản sao vì nó không yêu cầu tăng thêm nguyên tử và giảm số lượng tham chiếu.

Answer 3

Tôi đã upvoted câu trả lời của James McNellis. Tôi muốn nhận xét về câu trả lời của anh ấy nhưng nhận xét của tôi sẽ không phù hợp với định dạng nhận xét. Vì vậy, tôi đặt nó ở đây.

Một cách thú vị để đo lường tác động hiệu suất của việc di chuyển shared_ptr và sao chép một là sử dụng một cái gì đó như vector<shared_ptr<T>> để di chuyển hoặc sao chép toàn bộ nhóm và thời gian. Hầu hết các trình biên dịch có một cách để bật/tắt ngữ nghĩa di chuyển bằng cách chỉ định chế độ ngôn ngữ (ví dụ: -std = C++ 03 hoặc -std = C++ 11).

Đây là mã tôi chỉ thử nghiệm tại O3:

#include <chrono> 
#include <memory> 
#include <vector> 
#include <iostream> 

int main() 
{ 
    std::vector<std::shared_ptr<int> > v(10000, std::shared_ptr<int>(new int(3))); 
    typedef std::chrono::high_resolution_clock Clock; 
    typedef Clock::time_point time_point; 
    typedef std::chrono::duration<double, std::micro> us; 
    time_point t0 = Clock::now(); 
    v.erase(v.begin()); 
    time_point t1 = Clock::now(); 
    std::cout << us(t1-t0).count() << "\u00B5s\n"; 
} 

Sử dụng kêu vang/libC++ và trong -std = C++ 03 này in ra cho tôi:

195.368µs 

Switching để - std = C++ 11 Tôi nhận được:

16.422µs 

Số dặm của bạn có thể thay đổi.