Dlaczego std :: queue :: pop nie zwraca wartości.?

Przeszedłem przez tę stronę, ale nie mogę znaleźć powodu tego samego. Tam jest o tym mowa

„bardziej rozsądne jest, aby nie zwracał żadnej wartości i wymagał od klientów używania metody front () w celu sprawdzenia wartości na początku kolejki”

Ale sprawdzenie elementu z front () wymagało również skopiowania tego elementu w lvalue. Na przykład w tym segmencie kodu

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

/ * tutaj tymczasowe zostanie utworzone na RHS, które zostanie przypisane do wyniku, aw przypadku, gdy zwróci przez odniesienie, wynik zostanie unieważniony po operacji pop * /

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

w piątej linii obiekt cout najpierw tworzy kopię myqueue.front (), a następnie przypisuje ją do wyniku. Jaka jest różnica, funkcja pop mogłaby zrobić to samo.

Jaka jest różnica, funkcja pop mogłaby zrobić to samo.

Rzeczywiście mógł zrobić to samo. Powodem tego jest to, że pop, który zwrócił popped element, jest niebezpieczny w obecności wyjątków (konieczność zwracania wartości, a tym samym tworzenie kopii).

Rozważmy następujący scenariusz (z naiwną / zmyśloną implementacją pop, aby zilustrować mój punkt widzenia):

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
    }

Jeśli konstruktor kopiujący T zgłasza po powrocie, to już zmieniłeś stan kolejki ( top_positionw mojej naiwnej implementacji) i element jest usuwany z kolejki (i nie zwracany). W każdym przypadku (bez względu na to, w jaki sposób wyłapiesz wyjątek w kodzie klienta) element na początku kolejki jest tracony.

Ta implementacja jest również nieefektywna w przypadku, gdy nie potrzebujesz wartości popped (tj. Tworzy kopię elementu, którego nikt nie będzie używał).

Można to wdrożyć bezpiecznie i wydajnie za pomocą dwóch oddzielnych operacji ( void popi const T& front()).

Strona, do której masz łącze, odpowiada na Twoje pytanie.

Cytując cały odpowiedni dział:

Można by się zastanawiać, dlaczego pop () zwraca void zamiast value_type. To znaczy, dlaczego trzeba używać front () i pop (), aby sprawdzić i usunąć element na początku kolejki, zamiast łączyć te dwa elementy w jednej funkcji składowej? W rzeczywistości istnieje dobry powód dla tego projektu. Gdyby pop () zwróciło element frontowy, musiałby zwrócić wartość zamiast referencji: powrót przez referencję utworzyłby wiszący wskaźnik. Zwrot przez wartość jest jednak nieefektywny: wymaga co najmniej jednego nadmiarowego wywołania konstruktora kopiującego. Ponieważ pop () nie może zwrócić wartości w taki sposób, aby była zarówno wydajna, jak i poprawna, rozsądniej jest, aby nie zwracała żadnej wartości i wymagała od klientów użycia metody front () do sprawdzenia wartości w z przodu kolejki.

C ++ został zaprojektowany z myślą o wydajności, biorąc pod uwagę liczbę linii kodu, które musi napisać programista.

pop nie może zwrócić odwołania do usuwanej wartości, ponieważ jest ona usuwana ze struktury danych, więc do czego powinno odnosić się odwołanie? Może zwracać wartość, ale co, jeśli wynik pop nie jest nigdzie przechowywany? Wtedy marnuje się czas na niepotrzebne kopiowanie wartości.

Przy obecnej implementacji jest to ważne:

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

Jeśli pop zwróciłby odwołanie, takie jak to:

value_type& pop();

Następnie następujący kod może ulec awarii, ponieważ odwołanie jest już nieprawidłowe:

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

Z drugiej strony, gdyby zwrócił wartość bezpośrednio:

value_type pop();

Następnie musisz zrobić kopię, aby ten kod działał, co jest mniej wydajne:

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

Począwszy od C ++ 11 możliwe byłoby zarchiwizowanie żądanego zachowania przy użyciu semantyki przenoszenia. Lubię pop_and_move. Więc konstruktor kopiujący nie zostanie wywołany, a wydajność będzie zależeć tylko od konstruktora przenoszenia.

Możesz to całkowicie zrobić:

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

Lub, jeśli chcesz, aby wartość była zawarta w zmiennej, użyj odwołania:

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

Poza tym: sformułowanie „bardziej sensowne” jest subiektywną formą stwierdzenia, że ​​„przyjrzeliśmy się wzorcom użycia i stwierdziliśmy większą potrzebę podziału”. (Zapewniamy: język C ++ nie rozwija się lekko ...)

Myślę, że najlepszym rozwiązaniem byłoby dodanie czegoś takiego

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

gdzie value otrzyma wartość popped.

Zaletą jest to, że można go zaimplementować za pomocą operatora przypisania ruchu, podczas gdy użycie front + pop spowoduje utworzenie kopii.