Mengapa std :: queue :: pop mengembalikan nilai.?

Saya membuka halaman ini tetapi saya tidak bisa mendapatkan alasan yang sama. Di sana disebutkan itu

"lebih bijaksana untuk tidak mengembalikan nilai sama sekali dan meminta klien menggunakan front () untuk memeriksa nilai di depan antrean"

Tapi memeriksa elemen dari front () juga membutuhkan elemen itu untuk disalin di lvalue. Misalnya di segmen kode ini

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

/ * di sini sementara akan dibuat di kanan atas yang akan ditetapkan ke hasil, dan jika dikembalikan dengan referensi maka hasil akan dianggap tidak valid setelah operasi pop * /

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

pada baris kelima objek cout pertama membuat salinan myqueue.front () kemudian menetapkan itu ke hasil. Jadi, apa bedanya, fungsi pop bisa melakukan hal yang sama.

Jadi, apa bedanya, fungsi pop bisa melakukan hal yang sama.

Itu memang bisa melakukan hal yang sama. Alasannya tidak, adalah karena pop yang mengembalikan elemen yang muncul tidak aman jika ada pengecualian (harus mengembalikan berdasarkan nilai dan dengan demikian membuat salinan).

Pertimbangkan skenario ini (dengan implementasi pop yang naif / dibuat-buat, untuk mengilustrasikan maksud saya):

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
    }

Jika konstruktor salinan T melempar saat kembali, Anda telah mengubah status antrian ( top_positiondalam implementasi naif saya) dan elemen dihapus dari antrian (dan tidak dikembalikan). Untuk semua maksud dan tujuan (tidak peduli bagaimana Anda menangkap pengecualian dalam kode klien) elemen di bagian atas antrian hilang.

Implementasi ini juga tidak efisien jika Anda tidak membutuhkan nilai yang muncul (yaitu membuat salinan elemen yang tidak akan digunakan siapa pun).

Ini dapat diimplementasikan dengan aman dan efisien, dengan dua operasi terpisah ( void popdan const T& front()).

Halaman yang telah Anda tautkan untuk menjawab pertanyaan Anda.

Mengutip seluruh bagian yang relevan:

Orang mungkin bertanya-tanya mengapa pop () mengembalikan void, bukan value_type. Yaitu, mengapa seseorang harus menggunakan front () dan pop () untuk memeriksa dan menghapus elemen di depan antrian, alih-alih menggabungkan keduanya dalam satu fungsi anggota? Sebenarnya, ada alasan bagus untuk desain ini. Jika pop () mengembalikan elemen depan, itu harus dikembalikan dengan nilai daripada dengan referensi: kembali dengan referensi akan membuat penunjuk yang menggantung. Mengembalikan menurut nilai, bagaimanapun, tidak efisien: ini melibatkan setidaknya satu panggilan konstruktor salinan yang redundan. Karena pop () tidak mungkin mengembalikan nilai sedemikian rupa sehingga menjadi efisien dan benar, lebih masuk akal untuk tidak mengembalikan nilai sama sekali dan meminta klien menggunakan front () untuk memeriksa nilai di depan antrian.

C ++ dirancang dengan mempertimbangkan efisiensi, melebihi jumlah baris kode yang harus ditulis oleh programmer.

pop tidak dapat mengembalikan referensi ke nilai yang dihapus, karena sedang dihapus dari struktur data, jadi apa referensi yang harus dirujuk? Itu bisa dikembalikan dengan nilai, tetapi bagaimana jika hasil pop tidak disimpan di mana pun? Kemudian waktu terbuang untuk menyalin nilai yang tidak perlu.

Dengan implementasi saat ini, ini valid:

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

Jika pop mengembalikan referensi, seperti ini:

value_type& pop();

Kemudian kode berikut bisa macet, karena referensi tidak valid lagi:

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

Di sisi lain, jika itu akan mengembalikan nilai secara langsung:

value_type pop();

Kemudian Anda perlu menyalin agar kode ini berfungsi, yang kurang efisien:

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

Mulai dari C ++ 11 dimungkinkan untuk mengarsipkan perilaku yang diinginkan menggunakan semantik bergerak. Suka pop_and_move. Jadi copy konstruktor tidak akan dipanggil, dan kinerja akan bergantung pada konstruktor move saja.

Anda benar-benar dapat melakukan ini:

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

Atau, jika Anda menginginkan nilai dalam variabel, gunakan referensi:

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

Di samping itu: kata 'lebih masuk akal' adalah bentuk subjektif dari 'kami melihat pola penggunaan dan menemukan lebih banyak kebutuhan untuk pemisahan'. (Yakinlah: bahasa C ++ tidak berkembang begitu saja ...)

Saya pikir solusi terbaik adalah menambahkan sesuatu seperti

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

dimana nilai akan menerima nilai yang muncul.

Keuntungannya adalah dapat diimplementasikan dengan menggunakan operator penugasan pindah, sementara menggunakan front + pop akan membuat salinan.