Perché std :: queue :: pop non restituisce il valore.?

Ho esaminato questa pagina ma non sono in grado di ottenere il motivo per lo stesso. Là è detto che

"è più sensato che non restituisca alcun valore e richieda ai client di usare front () per ispezionare il valore all'inizio della coda"

Ma l'ispezione di un elemento da front () richiedeva anche che quell'elemento fosse copiato in lvalue. Ad esempio in questo segmento di codice

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

/ * qui verrà creato temporaneo su RHS che sarà assegnato al risultato, e nel caso in cui se ritorni per riferimento, il risultato sarà reso non valido dopo l'operazione pop * /

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

sulla quinta riga, l' oggetto cout crea prima una copia di myqueue.front (), quindi la assegna al risultato. Allora, qual è la differenza, la funzione pop avrebbe potuto fare la stessa cosa.

Allora, qual è la differenza, la funzione pop avrebbe potuto fare la stessa cosa.

Avrebbe potuto effettivamente fare la stessa cosa. Il motivo per cui non l'ha fatto è perché un pop che ha restituito l'elemento estratto non è sicuro in presenza di eccezioni (dovendo restituire per valore e quindi creare una copia).

Considera questo scenario (con un'implementazione pop ingenua / inventata, per illustrare il mio punto):

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
    }

Se il costruttore di copia di T lancia al ritorno, hai già modificato lo stato della coda ( top_positionnella mia implementazione ingenua) e l'elemento viene rimosso dalla coda (e non restituito). A tutti gli effetti (indipendentemente da come si cattura l'eccezione nel codice client) l'elemento in cima alla coda viene perso.

Questa implementazione è anche inefficiente nel caso in cui non sia necessario il valore estratto (ovvero crea una copia dell'elemento che nessuno utilizzerà).

Questo può essere implementato in modo sicuro ed efficiente, con due operazioni separate ( void pope const T& front()).

La pagina a cui ti sei collegato risponde alla tua domanda.

Per citare l'intera sezione rilevante:

Ci si potrebbe chiedere perché pop () restituisce void, invece di value_type. Cioè, perché si deve usare front () e pop () per esaminare e rimuovere l'elemento all'inizio della coda, invece di combinare i due in una singola funzione membro? In effetti, c'è una buona ragione per questo design. Se pop () restituisse l'elemento in primo piano, dovrebbe restituire per valore invece che per riferimento: il ritorno per riferimento creerebbe un puntatore penzolante. La restituzione per valore, tuttavia, è inefficiente: implica almeno una chiamata ridondante al costruttore di copia. Poiché è impossibile per pop () restituire un valore in modo tale da essere sia efficiente che corretto, è più sensato che non restituisca alcun valore e richieda ai client di utilizzare front () per ispezionare il valore in la parte anteriore della coda.

Il C ++ è progettato pensando all'efficienza, considerando il numero di righe di codice che il programmatore deve scrivere.

pop non può restituire un riferimento al valore rimosso, poiché viene rimosso dalla struttura dati, quindi a cosa deve fare riferimento il riferimento? Potrebbe restituire per valore, ma cosa succede se il risultato del pop non viene memorizzato da nessuna parte? Quindi si perde tempo a copiare il valore inutilmente.

Con l'attuale implementazione, questo è valido:

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

Se pop restituisse un riferimento, in questo modo:

value_type& pop();

Quindi il seguente codice potrebbe bloccarsi, poiché il riferimento non è più valido:

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

D'altra parte, se restituisse direttamente un valore:

value_type pop();

Quindi dovresti fare una copia affinché questo codice funzioni, che è meno efficiente:

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

A partire da C ++ 11 sarebbe possibile archiviare il comportamento desiderato utilizzando la semantica di spostamento. Mi piace pop_and_move. Quindi il costruttore di copia non verrà chiamato e le prestazioni dipenderanno solo dal costruttore di spostamento.

Puoi farlo totalmente:

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

Oppure, se vuoi il valore in una variabile, usa un riferimento:

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

Accanto a questo: la formulazione "più sensato" è una forma soggettiva di "abbiamo esaminato i modelli di utilizzo e abbiamo riscontrato più bisogno di una divisione". (Stai tranquillo: il linguaggio C ++ non si sta evolvendo leggermente ...)

Penso che la soluzione migliore sarebbe aggiungere qualcosa di simile

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

dove value riceverà il valore scoppiato.

Il vantaggio è che potrebbe essere implementato utilizzando un operatore di assegnazione di spostamento, mentre l'uso di front + pop farà una copia.