Tại sao std :: queue :: pop không trả về giá trị.?

Tôi đã xem qua trang này nhưng tôi không thể lấy được lý do tương tự. Ở đó nó được đề cập rằng

"hợp lý hơn nếu nó không trả về giá trị nào và yêu cầu khách hàng sử dụng front () để kiểm tra giá trị ở đầu hàng đợi"

Nhưng việc kiểm tra một phần tử từ front () cũng yêu cầu phần tử đó phải được sao chép trong lvalue. Ví dụ trong đoạn mã này

std::queue<int> myqueue;
int myint;
int result;
std::cin >> myint;
myqueue.push (myint);

/ * ở đây tạm thời sẽ được tạo trên RHS sẽ được gán cho kết quả, và trong trường hợp nếu trả về bằng tham chiếu thì kết quả sẽ không hợp lệ sau thao tác bật * /

result = myqueue.front();  //result.
std::cout << ' ' << result;
myqueue.pop();

trên đối tượng cout dòng thứ năm đầu tiên tạo một bản sao của myqueue.front () sau đó gán nó cho kết quả. Vì vậy, sự khác biệt là gì, chức năng pop có thể làm điều tương tự.

Vì vậy, sự khác biệt là gì, chức năng pop có thể đã làm điều tương tự.

Nó thực sự có thể đã làm điều tương tự. Lý do mà nó không, là vì một cửa sổ bật lên trả về phần tử được bật lên không an toàn khi có các ngoại lệ (phải trả về theo giá trị và do đó tạo ra một bản sao).

Hãy xem xét tình huống này (với một triển khai pop ngây thơ / được tạo ra, để củng cố quan điểm của tôi):

template<class T>
class queue {
    T* elements;
    std::size_t top_position;
    // stuff here
    T pop()
    {
        auto x = elements[top_position];
        // TODO: call destructor for elements[top_position] here
        --top_position;  // alter queue state here
        return x;        // calls T(const T&) which may throw
    }

Nếu hàm tạo bản sao của T ném trở lại, bạn đã thay đổi trạng thái của hàng đợi ( top_positiontrong cách triển khai ngây thơ của tôi) và phần tử bị xóa khỏi hàng đợi (và không được trả lại). Đối với tất cả các ý định và mục đích (bất kể bạn bắt ngoại lệ bằng cách nào trong mã máy khách), phần tử ở đầu hàng đợi sẽ bị mất.

Việc triển khai này cũng không hiệu quả trong trường hợp bạn không cần giá trị được bật lên (tức là nó tạo ra một bản sao của phần tử mà không ai sẽ sử dụng).

Điều này có thể được thực hiện một cách an toàn và hiệu quả, với hai hoạt động riêng biệt ( void popvà const T& front()).

Trang bạn đã liên kết để trả lời câu hỏi của bạn.

Để trích dẫn toàn bộ phần có liên quan:

Người ta có thể thắc mắc tại sao pop () trả về void, thay vì value_type. Đó là, tại sao người ta phải sử dụng front () và pop () để kiểm tra và loại bỏ phần tử ở phía trước hàng đợi, thay vì kết hợp cả hai trong một hàm thành viên? Trên thực tế, có một lý do chính đáng cho thiết kế này. Nếu pop () trả về phần tử phía trước, nó sẽ phải trả về theo giá trị thay vì tham chiếu: trả về bằng tham chiếu sẽ tạo ra một con trỏ treo lơ lửng. Tuy nhiên, trả về theo giá trị không hiệu quả: nó liên quan đến ít nhất một lệnh gọi hàm tạo bản sao dự phòng. Vì pop () không thể trả lại giá trị theo cách vừa hiệu quả vừa chính xác, nên hợp lý hơn là nó không trả về giá trị nào và yêu cầu khách hàng sử dụng front () để kiểm tra giá trị tại mặt trước của hàng đợi.

C ++ được thiết kế với tính hiệu quả, vượt quá số dòng mã mà lập trình viên phải viết.

pop không thể trả về một tham chiếu đến giá trị bị xóa, vì nó đang bị xóa khỏi cấu trúc dữ liệu, vậy tham chiếu phải tham chiếu đến giá trị nào? Nó có thể trả về theo giá trị, nhưng nếu kết quả của pop không được lưu trữ ở đâu thì sao? Sau đó, lãng phí thời gian sao chép giá trị một cách không cần thiết.

Với việc triển khai hiện tại, điều này là hợp lệ:

int &result = myqueue.front();
std::cout << result;
myqueue.pop();

Nếu pop sẽ trả về một tham chiếu, như thế này:

value_type& pop();

Sau đó, mã sau có thể bị lỗi, vì tham chiếu không còn hợp lệ nữa:

int &result = myqueue.pop();
std::cout << result;

Mặt khác, nếu nó sẽ trả về một giá trị trực tiếp:

value_type pop();

Sau đó, bạn sẽ cần tạo một bản sao để mã này hoạt động, mã này kém hiệu quả hơn:

int result = myqueue.pop();
std::cout << result;

Bắt đầu từ C ++ 11, có thể lưu trữ hành vi mong muốn bằng cách sử dụng ngữ nghĩa di chuyển. Thích pop_and_move. Vì vậy, hàm tạo bản sao sẽ không được gọi và hiệu suất sẽ chỉ phụ thuộc vào hàm tạo di chuyển.

Bạn hoàn toàn có thể làm được điều này:

std::cout << ' ' << myqueue.front();

Hoặc, nếu bạn muốn giá trị trong một biến, hãy sử dụng tham chiếu:

const auto &result = myqueue.front();
if (result > whatever) do_whatever();
std::cout << ' ' << result;

Bên cạnh đó: từ ngữ 'hợp lý hơn' là một dạng chủ quan của việc 'chúng tôi đã xem xét các kiểu sử dụng và thấy cần nhiều sự phân tách hơn'. (Hãy yên tâm: ngôn ngữ C ++ phát triển không hề nhẹ ...)

Tôi nghĩ giải pháp tốt nhất là thêm một số thứ như

std::queue::pop_and_store(value_type& value);

trong đó giá trị sẽ nhận giá trị được bật lên.

Ưu điểm là nó có thể được thực hiện bằng cách sử dụng toán tử gán di chuyển, trong khi sử dụng front + pop sẽ tạo một bản sao.