Là pass-by-value có phải là mặc định hợp lý trong C ++ 11 không?

Trong C ++ truyền thống, việc truyền giá trị vào các hàm và phương thức là chậm đối với các đối tượng lớn và thường được tán thành. Thay vào đó, các lập trình viên C ++ có xu hướng chuyển các tham chiếu xung quanh, nhanh hơn, nhưng đưa ra tất cả các loại câu hỏi phức tạp xung quanh quyền sở hữu và đặc biệt là về quản lý bộ nhớ (trong trường hợp đối tượng được phân bổ heap)

Bây giờ, trong C ++ 11, chúng ta có các tham chiếu Rvalue và di chuyển các hàm tạo, điều đó có nghĩa là có thể thực hiện một đối tượng lớn (như một std::vector) giá rẻ để truyền giá trị vào và ra khỏi hàm.

Vì vậy, điều này có nghĩa là mặc định sẽ được truyền theo giá trị cho các thể hiện của các loại như std::vectorvà std::string? Còn đối với các đối tượng tùy chỉnh thì sao? Thực hành mới tốt nhất là gì?

Đó là một mặc định hợp lý nếu bạn cần tạo một bản sao bên trong cơ thể. Đây là những gì Dave Abrahams đang ủng hộ :

Hướng dẫn: Không sao chép đối số chức năng của bạn. Thay vào đó, chuyển chúng theo giá trị và để trình biên dịch thực hiện sao chép.

Trong mã này có nghĩa là không làm điều này:

void foo(T const& t)
{
    auto copy = t;
    // ...
}

nhưng làm điều này:

void foo(T t)
{
    // ...
}

có lợi thế mà người gọi có thể sử dụng foonhư vậy:

T lval;
foo(lval); // copy from lvalue
foo(T {}); // (potential) move from prvalue
foo(std::move(lval)); // (potential) move from xvalue

và chỉ có công việc tối thiểu được thực hiện. Bạn sẽ cần hai quá tải để làm tương tự với các tham chiếu void foo(T const&);và void foo(T&&);.

Với ý nghĩ đó, bây giờ tôi đã viết các hàm tạo có giá trị của mình như sau:

class T {
    U u;
    V v;
public:
    T(U u, V v)
        : u(std::move(u))
        , v(std::move(v))
    {}
};

Nếu không, chuyển qua tham chiếu đến constvẫn là hợp lý.

Trong hầu hết các trường hợp, ngữ nghĩa của bạn phải là:

bar(foo f); // want to obtain a copy of f
bar(const foo& f); // want to read f
bar(foo& f); // want to modify f

Tất cả các chữ ký khác chỉ nên được sử dụng một cách tiết kiệm và với sự biện minh tốt. Trình biên dịch bây giờ sẽ khá nhiều luôn luôn làm việc này theo cách hiệu quả nhất. Bạn chỉ có thể nhận được bằng cách viết mã của bạn!

Truyền tham số theo giá trị nếu bên trong thân hàm bạn cần một bản sao của đối tượng hoặc chỉ cần di chuyển đối tượng. Đi qua const&nếu bạn chỉ cần truy cập không đột biến vào đối tượng.

Ví dụ sao chép đối tượng:

void copy_antipattern(T const& t) { // (Don't do this.)
    auto copy = t;
    t.some_mutating_function();
}

void copy_pattern(T t) { // (Do this instead.)
    t.some_mutating_function();
}

Ví dụ di chuyển đối tượng:

std::vector<T> v; 

void move_antipattern(T const& t) {
    v.push_back(t); 
}

void move_pattern(T t) {
    v.push_back(std::move(t)); 
}

Ví dụ truy cập không đột biến:

void read_pattern(T const& t) {
    t.some_const_function();
}

Để biết lý do, hãy xem những bài đăng trên blog của Dave Abrahams và Xiang Fan .

Chữ ký của một chức năng sẽ phản ánh mục đích sử dụng của nó. Khả năng đọc là quan trọng, cũng cho trình tối ưu hóa.

Đây là điều kiện tiên quyết tốt nhất để một trình tối ưu hóa tạo mã nhanh nhất - về lý thuyết ít nhất và nếu không có trong thực tế thì trong một vài năm thực tế.

Xem xét hiệu suất rất thường được đánh giá cao trong bối cảnh truyền tham số. Chuyển tiếp hoàn hảo là một ví dụ. Các chức năng như emplace_backhầu hết là rất ngắn và nội tuyến.