Neden std :: queue :: pop değeri dönmüyor?

Bu sayfadan geçtim ama bunun sebebini anlayamıyorum. Orada bahsediliyor

"hiç bir değer döndürmemesi ve istemcilerin sıranın önündeki değeri incelemek için front () kullanmasını gerektirmesi daha mantıklıdır"

Ancak front () 'den bir öğeyi incelemek, o öğenin lvalue içinde kopyalanmasını da gerektiriyordu. Örneğin bu kod segmentinde

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

/ * burada sonuca atanacak olan RHS'de geçici oluşturulacak ve referansla döndürülmesi durumunda pop işleminden sonra sonuç geçersiz kılınacak * /

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

beşinci satırda cout nesnesi önce myqueue.front () 'un bir kopyasını oluşturur ve ardından bunu sonuca atar. Öyleyse, fark ne, pop işlevi de aynı şeyi yapmış olabilir.

Öyleyse, fark nedir, pop işlevi de aynı şeyi yapmış olabilir.

Gerçekten de aynı şeyi yapabilirdi. Bunun yapılmamasının nedeni, patlatılan öğeyi döndüren bir pop'un istisnaların varlığında güvenli olmamasıdır (değere göre dönmek zorunda kalmak ve böylece bir kopya oluşturmak).

Bu senaryoyu düşünün (benim fikrimi aydınlatmak için saf / uydurma bir pop uygulamasıyla):

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
    }

T'nin kopya yapıcısı dönüşte atarsa, kuyruğun durumunu zaten değiştirmişsinizdir ( top_positionbenim saf uygulamamda) ve öğe kuyruktan kaldırılır (ve geri döndürülmez). Tüm amaçlar ve amaçlar için (istemci kodundaki istisnayı nasıl yakaladığınız önemli değil), kuyruğun üst kısmındaki öğe kaybolur.

Bu uygulama, aynı zamanda, atılan değere ihtiyaç duymadığınız durumlarda da verimsizdir (yani, kimsenin kullanmayacağı öğenin bir kopyasını oluşturur).

Bu, iki ayrı işlemle ( void popve const T& front()) güvenli ve verimli bir şekilde uygulanabilir .

Bağlandığınız sayfa sorunuzu yanıtlar.

İlgili tüm bölümden alıntı yapmak için:

Pop () 'un neden value_type yerine void döndürdüğünü merak edebilirsiniz. Yani, neden ikisini tek bir üye işlevinde birleştirmek yerine sıranın önündeki öğeyi incelemek ve kaldırmak için front () ve pop () kullanmak gerekir? Aslında bu tasarımın iyi bir nedeni var. Pop () ön öğeyi döndürdüyse, başvuru yerine değere göre döndürmesi gerekirdi: başvuruya göre döndürme sarkan bir işaretçi oluşturacaktır. Ancak değere göre dönüş verimsizdir: en az bir yedek kopya yapıcı çağrısı içerir. Pop () 'un bir değeri hem verimli hem de doğru olacak şekilde döndürmesi imkansız olduğundan, hiç değer döndürmemesi ve istemcilerden, değeri incelemek için front () kullanmalarını istemek daha mantıklıdır. sıranın önü.

C ++, programcının yazması gereken kod satırı sayısından daha fazla verimlilik göz önünde bulundurularak tasarlanmıştır.

pop, veri yapısından kaldırıldığı için kaldırılan değere bir başvuru döndüremez, öyleyse başvuru neyi ifade etmelidir? Değere göre dönebilir, ancak ya pop'un sonucu hiçbir yerde saklanmadıysa? Daha sonra değeri gereksiz yere kopyalayarak zaman boşa harcanır.

Mevcut uygulamayla bu geçerlidir:

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

Pop, şöyle bir referans döndürürse:

value_type& pop();

Bu durumda, referans artık geçerli olmadığından aşağıdaki kod çökebilir:

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

Öte yandan, doğrudan bir değer döndürürse:

value_type pop();

O zaman bu kodun çalışması için daha az verimli olan bir kopya yapmanız gerekir:

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

C ++ 11'den başlayarak, hareket semantiğini kullanarak istenen davranışı arşivlemek mümkün olacaktır. Beğen pop_and_move. Bu nedenle, kopya oluşturucu çağrılmayacak ve performans yalnızca taşıma yapıcısına bağlı olacaktır.

Bunu tamamen yapabilirsiniz:

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

Veya bir değişkendeki değeri istiyorsanız bir referans kullanın:

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

Bunun yanında, 'daha mantıklı' ifadesi, 'kullanım kalıplarını inceledik ve bölünmeye daha fazla ihtiyaç duyduk' ifadesinin öznel bir biçimidir. (İçiniz rahat olsun: C ++ dili hafifçe gelişmiyor ...)

En iyi çözümün şöyle bir şey eklemek olduğunu düşünüyorum:

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

değer, atılan değeri alacaktır.

Avantajı, bir taşıma atama operatörü kullanılarak uygulanabilmesidir, ön + pop kullanımı ise bir kopya oluşturur.