Tại sao chức năng chuyển tiếp hoàn hảo phải được tạo mẫu?

Question

Tại sao đoạn mã sau hợp lệ:

template<typename T1> 
void foo(T1 &&arg) { bar(std::forward<T1>(arg)); } 

std::string str = "Hello World"; 
foo(str); // Valid even though str is an lvalue 
foo(std::string("Hello World")); // Valid because literal is rvalue 

Nhưng không:

void foo(std::string &&arg) { bar(std::forward<std::string>(arg)); } 

std::string str = "Hello World"; 
foo(str); // Invalid, str is not convertible to an rvalue 
foo(std::string("Hello World")); // Valid 

Tại sao không phải là giá trị trái trong ví dụ 2 được giải quyết trong cùng một cách thức mà nó trong ví dụ 1?

Ngoài ra, tại sao tiêu chuẩn cảm thấy cần phải cung cấp loại đối số trong std :: forward so với simple deducing it? Chỉ cần gọi về phía trước là hiển thị ý định, bất kể loại nào.

Nếu đây không phải là một điều tiêu chuẩn và chỉ trình biên dịch của tôi, tôi đang sử dụng msvc10, điều này sẽ giải thích sự hỗ trợ C++ 11 crappy.

Cảm ơn

Sửa 1: Thay đổi chữ "Hello World" được std :: string ("Hello World") để thực hiện một rvalue.

Answer 1

Trước hết, read this để có ý tưởng chuyển tiếp đầy đủ. (Có, tôi đang ủy quyền hầu hết các câu trả lời này ở nơi khác.)

Để tóm tắt, chuyển tiếp có nghĩa là các giá trị giữ nguyên giá trị và giá trị giữ nguyên giá trị. Bạn không thể làm điều đó với một loại duy nhất, vì vậy bạn cần hai. Vì vậy, đối với mỗi đối số được chuyển tiếp, bạn cần hai phiên bản cho đối số đó, yêu cầu tổng số kết hợp là 2 ^N cho hàm. Bạn có thể mã tất cả các kết hợp của hàm, nhưng nếu bạn sử dụng mẫu thì các kết hợp khác nhau sẽ được tạo cho bạn khi cần.

---

Nếu bạn đang cố gắng để tối ưu hóa các bản sao và di chuyển, chẳng hạn như trong:

struct foo 
{ 
    foo(const T& pX, const U& pY, const V& pZ) : 
    x(pX), 
    y(pY), 
    z(pZ) 
    {} 

    foo(T&& pX, const U& pY, const V& pZ) : 
    x(std::move(pX)), 
    y(pY), 
    z(pZ) 
    {} 

    // etc.? :(

    T x; 
    U y; 
    V z; 
}; 

Sau đó, bạn nên dừng lại và làm điều đó theo cách này:

struct foo 
{ 
    // these are either copy-constructed or move-constructed, 
    // but after that they're all yours to move to wherever 
    // (that is, either: copy->move, or move->move) 
    foo(T pX, U pY, V pZ) : 
    x(std::move(pX)), 
    y(std::move(pY)), 
    z(std::move(pZ)) 
    {} 

    T x; 
    U y; 
    V z; 
}; 

Bạn chỉ cần một constructor. Hướng dẫn: nếu bạn cần bản sao dữ liệu của riêng mình, hãy tạo bản sao đó trong danh sách tham số; điều này cho phép quyết định sao chép hoặc di chuyển đến người gọi và trình biên dịch.